Programming JavaScript Applications

Index

A note on the digital index

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

Symbols

() (parentheses), Method Context

A

acceptance criteria, Defining the App

access control, Access Control, Authentication–Delegated authentication, Authorization–OAuth 2.0, Conclusion

about, Access Control

authentication, Authentication–Delegated authentication

authorization, Authorization–OAuth 2.0

recommendations, Conclusion

access control lists (ACLs), Authorization

ACLs (access control lists), Authorization

ad-hoc polymorphism, Generics and Collection Polymorphism

.addEventListener() method, Function.prototype.bind()

.addTo() function, Lambdas

affordances (hypermedia), Affordances

agile development methods, Defining the App

Ajax technology, The JavaScript Revolution, Promises and Deferreds

alerts, logging, Logging Service Alerts

Alman, Ben, Immediately Invoked Function Expressions

Amazon Simple Queue Service (SQS), Queues and stacks

AMD (asynchronous module definition), Asynchronous Module Definition–Asynchronous Module Definition, Plug-Ins–Plug-Ins, Jiron

about, Asynchronous Module Definition–Asynchronous Module Definition

exporting, Jiron

loader plug-ins, Plug-Ins–Plug-Ins

Amundsen, Mike, Affordances

Angular library, Model View Controller/MV*

anonymous functions, Function Definition–Named Function Expressions, Immediately Invoked Function Expressions

about, Function Definition–Named Function Expressions

self-invoked, Immediately Invoked Function Expressions

AppDynamics tool, Profiling and Instrumentation

application development, Defining the App–Feature Implementation, Feature Implementation–Feature Implementation, Bundling and Deployment–Bundling and Deployment, Code Quality

bundling and deployment, Bundling and Deployment–Bundling and Deployment

code quality, Code Quality

defining the app, Defining the App–Feature Implementation

feature implementation, Feature Implementation–Feature Implementation

args array, Function Polymorphism

arguments object, Function Polymorphism

arity (functions), Named Parameters

Armstrong, Joe, Classical Inheritance Is Obsolete

array literal notation, Fluent-Style JavaScript

Array.prototype.shift() method, Function Polymorphism

Array.prototype.slice() method, Function Polymorphism

Array.sort() method, Functional Programming

arrays, Generics and Collection Polymorphism, Objects

as collections, Generics and Collection Polymorphism

as objects, Objects

The Art of Agile Development (Shore), Defining the App

ASI (automatic semicolon insertion), Use Semicolons

aspect-oriented programming, Client-Side Concerns

asynchronous module definition (AMD), Asynchronous Module Definition–Asynchronous Module Definition, Plug-Ins–Plug-Ins, Jiron

about, Asynchronous Module Definition–Asynchronous Module Definition

exporting, Jiron

loader plug-ins, Plug-Ins–Plug-Ins

asynchronous operations, Stateless Functions (aka Pure Functions), Asynchronous Operations, Callbacks, Promises and Deferreds–Promises and Deferreds, Asynchronous Module Definition–Plug-Ins

about, Asynchronous Operations

AMD support, Asynchronous Module Definition–Plug-Ins

callback functions, Callbacks

promises and deferreds, Promises and Deferreds–Promises and Deferreds

stateless functions and, Stateless Functions (aka Pure Functions)

asyncTest() function, Closures

Atwood’s Law, The JavaScript Revolution

audit trails, logging, Auditing

Aura module management, Module Management

authentication, Authentication, Passwords–Stolen passwords, Credential–Credential, Multifactor Authentication–Inherence factor, Federated and Delegated Authentication–WebID, Delegated authentication–Delegated authentication

about, Authentication

Credential library, Credential–Credential

delegated, Delegated authentication–Delegated authentication

federated, Federated and Delegated Authentication–WebID

multifactor, Multifactor Authentication–Inherence factor

passwords and, Passwords–Stolen passwords

authorization, Authorization, Authorizing Applications, OAuth 2.0

about, Authorization

applications and, Authorizing Applications

OAuth 2.0 standard, OAuth 2.0

Authy (authentication product), Possession factor

automatic semicolon insertion (ASI), Use Semicolons

B

Backbone.js library, Client-Side Concerns, Event emitters, Event aggregators, Events by example, Events by example, Model View Controller/MV*, Model View Controller/MV*, Model View Controller/MV*, Model View Controller/MV*, Model View Controller/MV*, Model View Controller/MV*, Model View Controller/MV*, Presentation and DOM Manipulation, Presentation and DOM Manipulation, Templates–Templates

about, Client-Side Concerns, Model View Controller/MV*

application presentation, Presentation and DOM Manipulation

Collection constructor, Model View Controller/MV*

event aggregators and, Event aggregators, Model View Controller/MV*

event emitters and, Event emitters, Events by example

.extend() method, Model View Controller/MV*

Model constructor, Events by example, Model View Controller/MV*

Router constructor, Model View Controller/MV*

template support, Templates–Templates

View constructor, Model View Controller/MV*, Presentation and DOM Manipulation

behavior delegation, Method dispatch

best practices reference, Best Practices Quick Reference, Indentation: Be Consistent, Use Semicolons, Bracket Placement: Right Side, Avoid Name Collisions, Always Use var, Use One var Statement per Function, Avoid Constant Abuse–Use Functional Iterators When Possible, Use Functional Iterators When Possible–Use Functional Iterators When Possible, Be Careful with if Statements–Be Careful with if Statements, Avoid Side Effects–Don’t Use switch, Don’t Use switch–Don’t Use switch, Don’t Use eval()

about, Best Practices Quick Reference

bracket placement, Bracket Placement: Right Side

constants, Avoid Constant Abuse–Use Functional Iterators When Possible

eval() function, Don’t Use eval()

functions, Use One var Statement per Function, Use Functional Iterators When Possible–Use Functional Iterators When Possible

if statement, Be Careful with if Statements–Be Careful with if Statements

indentation, Indentation: Be Consistent

name collisions, Avoid Name Collisions

semicolons, Use Semicolons

side effects, Avoid Side Effects–Don’t Use switch

switch statement, Don’t Use switch–Don’t Use switch

var keyword, Always Use var

block scope, Function Scope

Bootstrap framework, Defining the App

botnets, Passwords, Brute force

bracket placement (best practice), Bracket Placement: Right Side

Braithwaite, Reginald, Conclusion

Browserify module, Plug-Ins, Bundling and Deployment, Bundling and Deployment, Templates, Jiron

about, Bundling and Deployment, Bundling and Deployment

AMD and, Plug-Ins, Jiron

template support, Templates

browsers, Named Function Expressions, Model View Controller/MV*, Web Components–Web Components, Mozilla Persona, Use common conventions

event emitters and, Model View Controller/MV*

federated authentication, Mozilla Persona

named function expressions, Named Function Expressions

RESTful APIs and, Use common conventions

Web Components and, Web Components–Web Components

brute force attacks, Brute force–Brute force

Building Hypermedia APIs with HTML5 and Node (Amundsen), Affordances

Bunyan logger, Logging Requests

business analytics, Business Analytics–Viral Factor

C

callback functions, Lambdas, Callbacks, Promises and Deferreds

about, Callbacks

lambdas and, Lambdas

promises and, Promises and Deferreds

CDN (Content Deliver Network), Infrastructure

churn rate KPI, Business Analytics

circular references, JSON: Data Storage and Communication

class keyword, Prototypal Inheritance with Stamps

CLDR (Common Locale Data Repository), Internationalization

client-side operations, Asynchronous Module Definition–Plug-Ins, Building Client-Side Code with CommonJS, npm, Grunt, and Browserify–Bundling and Deployment, Client-Side Concerns–Web Components, Module Management–Registration, loading, and rendering, Events–Events by example, Model View Controller/MV*–Model View Controller/MV*, Presentation and DOM Manipulation–Web Components, Presentation and DOM Manipulation–Web Components, Logging Requests, Logging Client-Side Events

AMD support, Asynchronous Module Definition–Plug-Ins

application presentation, Presentation and DOM Manipulation–Web Components

building code, Building Client-Side Code with CommonJS, npm, Grunt, and Browserify–Bundling and Deployment

DOM manipulation, Presentation and DOM Manipulation–Web Components

handling events, Events–Events by example

logging events, Logging Requests, Logging Client-Side Events

module management, Module Management–Registration, loading, and rendering

MVC architecture, Model View Controller/MV*–Model View Controller/MV*

separation of concerns, Client-Side Concerns–Web Components

client/server communication, Syntax, Reusability, JSON: Data Storage and Communication, RESTful JSON Web Services–RESTful JSON Web Services, Separation of Concerns–Conclusion

code reusability in, Reusability

JSON and, Syntax, JSON: Data Storage and Communication

RESTful web services and, RESTful JSON Web Services–RESTful JSON Web Services

separation of concerns, Separation of Concerns–Conclusion

cloning prototypes, Prototype Cloning–Prototype Cloning

closures (function scope), Lambdas, Closures–Closures, Partial Application and Currying, Fluent-Style JavaScript

about, Closures–Closures, Fluent-Style JavaScript

lambdas and, Lambdas

partial application and, Partial Application and Currying

CLTV (Customer Lifetime Value), Business Analytics

CMS (Content Management System), Infrastructure

Coders at Work (Siebel), Classical Inheritance Is Obsolete

collection polymorphism, Generics and Collection Polymorphism

Common Locale Data Repository (CLDR), Internationalization

CommonJS project, Promises and Deferreds, The Module Pattern, Asynchronous Module Definition, Node-Style Modules

about, The Module Pattern

asynchronous modules and, Asynchronous Module Definition

module implementations, Node-Style Modules

Promises/A design, Promises and Deferreds

consistency (design principle), Usable, Consistency, Use common conventions–Resourceful routing, Resourceful routing–Resourceful routing

about, Usable, Consistency

common conventions, Use common conventions–Resourceful routing

resourceful routing, Resourceful routing–Resourceful routing

console object, Hoisting, Debugging, Debugging

log() method, Hoisting

timeEnd() method, Debugging

trace() method, Debugging

constant time hash equality check, Variable time equality

constants (best practice), Avoid Constant Abuse–Use Functional Iterators When Possible

constructor functions, Fluent-Style JavaScript, Object Creation–Object Creation

Content Deliver Network (CDN), Infrastructure

Content Management System (CMS), Infrastructure

continuous deployment, Feature Toggle

controller (MVC), Model View Controller/MV*

controls, defined, Separation of Concerns

conversion goals, logging, Logging Goals

CouchDB data stores, NoSQL Data Stores

Credential library, Credential–Credential

Crockford, Douglas, Who This Book Is Not For, JSON: Data Storage and Communication, The Module Pattern, JavaScript Style Guide, Best Practices Quick Reference

CRUD acronym, RESTful JSON Web Services, Resourceful routing

crypto module, Password salts, Brute force

pbkdf2() function, Brute force

randomBytes() function, Password salts

CSS (Cascading Style Sheets), Defining the App, Bundling and Deployment, Templates, Web Components

Bootstrap framework and, Defining the App

shadow DOM and, Web Components

template support, Templates

usage tips, Bundling and Deployment

css! plug-in, Plug-Ins

Curl.js, Plug-Ins

currying process, Partial Application and Currying

customer acquisition cost KPI, Business Analytics

Customer Lifetime Value (CLTV), Business Analytics

D

data storage, JSON: Data Storage and Communication–NoSQL Data Stores

data structures, as objects, Objects

debug messages, logging, Debugging–Debugging

deciphering data, Deciphering Data

default activation phase (feature-toggle), Default Activation

.Deferred() method, Promises and Deferreds

deferreds (objects), Promises and Deferreds

delegate prototypes, Delegate Prototypes–Delegate Prototypes, Prototypal Inheritance with Stamps

delegated authentication, Delegated authentication–Delegated authentication

DELETE verb (HTTP), RESTful JSON Web Services, Resourceful routing

Design Patterns (Gamma et al.), Who This Book Is Not For

Design Patterns (Gang of Four), Classical Inheritance Is Obsolete–Classical Inheritance Is Obsolete, Interfaces

design principles, Functions, Method Design, Classical Inheritance Is Obsolete, Principles of Modularity, Building RESTful APIs–Conclusion

development guidelines, Functions

methods, Method Design

modules, Principles of Modularity

object-oriented design, Classical Inheritance Is Obsolete

RESTful APIs, Building RESTful APIs–Conclusion

development phase (feature-toggle), Development

Do One Thing (DOT), Functions

Dojo framework, Client-Side Concerns

DOM (Document Object Model), Event emitters, Model View Controller/MV*, Presentation and DOM Manipulation–Web Components, Event delegation–Event delegation, Templates–Templates, Web Components–Web Components

client-side manipulation, Presentation and DOM Manipulation–Web Components

event delegation, Event delegation–Event delegation

event emitters, Event emitters, Model View Controller/MV*

shadow DOM, Web Components–Web Components

template support, Templates–Templates

domain-specific language (DSL), Method Chaining and Fluent APIs

Don’t Repeat Yourself (DRY), Functions

DOT (Do One Thing), Functions

dot notation, Method Context–Method Context

DRY (Don’t Repeat Yourself), Functions

DSL (domain-specific language), Method Chaining and Fluent APIs

ducktyping, Be Careful with if Statements

dynamic dispatch, Method dispatch

Dynamic HTML (Goodman), Events

dynamic object extension, Fluent-Style JavaScript–Fluent-Style JavaScript

E

ECMAScript specifications, Lambdas, ES6 Modules

ES6 modules and, ES6 Modules

functional enumerators, Lambdas

encapsulation, Object Creation, Factories–Factories, Prototypal Inheritance with Stamps, Modules

modules and, Modules

private data and, Object Creation, Factories–Factories, Prototypal Inheritance with Stamps

environment variables, Configuration

equal() function, Closures, QUnit Primer

error handling, Middleware–Let it crash, Logging Errors–Sample Log Output, Logging Errors, Use common conventions

Express framework, Middleware–Let it crash, Logging Errors

logging errors, Logging Errors–Sample Log Output

RESTful APIs, Use common conventions

eval() function, Function Definition, Don’t Use eval()

events, Events, Function.prototype.bind(), Callbacks, Events, Event emitters, Event aggregators, Queues and stacks, Choosing the right event model, Events by example–Events by example, Events by example, Model View Controller/MV*, View events, Event delegation–Event delegation, Event delegation, Logging Requests, Logging Client-Side Events

about, Events

.bind() method and, Function.prototype.bind()

callback functions and, Callbacks

choosing event models, Choosing the right event model

event aggregators, Event aggregators, Model View Controller/MV*, Event delegation

event delegation, Event delegation–Event delegation

event emitters, Event emitters, Events by example

by example, Events by example–Events by example

JavaScript advantages, Events

logging, Logging Requests, Logging Client-Side Events

message queues, Queues and stacks

specifying event handlers, View events

.every() method, Generics and Collection Polymorphism

export keyword, ES6 Modules

Express framework, Installing Node and Express, Installing Node and Express, Express, Create your app, Routing, Middleware–Let it crash, Middleware, Templates, Logging Errors

about, Installing Node and Express, Express

creating app instance, Create your app

error handling, Middleware, Logging Errors

installing, Installing Node and Express

middleware support, Middleware–Let it crash

routing considerations, Routing

templates support, Templates

express-error-handler module, Use common conventions

.extend() method, Named Parameters, Named Parameters, Prototype Cloning, Prototype Cloning, Interfaces, Model View Controller/MV*

Backbone support, Model View Controller/MV*

jQuery support, Named Parameters, Prototype Cloning, Interfaces

Underscore support, Named Parameters, Prototype Cloning

Extensible Markup Language (XML), NoSQL Data Stores

F

Facebook, Delegated authentication, Authorizing Applications, OAuth 2.0

authentication and, Delegated authentication

authorization and, Authorizing Applications

OAuth 2.0 support, OAuth 2.0

facial recognition, Inherence factor

factories, Fluent-Style JavaScript, Factories–Prototypal Inheritance with Stamps, Interfaces

about, Fluent-Style JavaScript, Factories–Prototypal Inheritance with Stamps

defining, Interfaces

false positives in testing, Defining the App

feature toggle systems, Feature Toggle

features, Feature Implementation–Feature Implementation, Organizing Features–Feature Groups, Scale of a Feature, Feature Groups, Lifespan of a Feature–Full Integration, Implementation–Implementation

grouping together, Feature Groups

implementing, Feature Implementation–Feature Implementation, Implementation–Implementation

lifespan of, Lifespan of a Feature–Full Integration

organizing, Organizing Features–Feature Groups

scale of, Scale of a Feature

federated authentication, Federated and Delegated Authentication–WebID

Fielding, Roy T., Affordances–HATEOAS

fingerprint scanners, Inherence factor

first-class functions, First-Class Functions, Lambdas

Flannagan, David, Who This Book Is Not For

Flatiron HTTP Module, Node-Style Modules

fluent APIs, Method Chaining and Fluent APIs–Method Chaining and Fluent APIs, Fluent-Style JavaScript

fluent style JavaScript, Fluent-Style JavaScript–Fluent-Style JavaScript

flyweight pattern, The Flyweight Pattern–The Flyweight Pattern

focus (design principle), Usable–Focus

.forEach() function, Lambdas, Functional Programming

Fowler, Martin, Choosing the right event model

full integration phase (feature-toggle), Full Integration

function declarations, Function Definition–Function Definition, Named Function Expressions, Hoisting

about, Function Definition–Function Definition

hoisting and, Hoisting

named function expressions and, Named Function Expressions

function decorators, Lambdas

function definition, Function Definition–Function Definition, Named Function Expressions–Lambdas, Lambdas–Lambdas, Immediately Invoked Function Expressions–Method Context, Method Context–Function.prototype.bind()

about, Function Definition–Function Definition

function expressions, Named Function Expressions–Lambdas, Immediately Invoked Function Expressions–Method Context

lambdas, Lambdas–Lambdas

method context, Method Context–Function.prototype.bind()

function expressions, Function Definition, Named Function Expressions–Lambdas, Immediately Invoked Function Expressions–Method Context, Hoisting

about, Function Definition

hoisting and, Hoisting

IIFE, Immediately Invoked Function Expressions–Method Context

named, Named Function Expressions–Lambdas

function scope, Lambdas, Function Scope, Hoisting–Closures, Closures–Closures, Partial Application and Currying, Fluent-Style JavaScript, Prototypal Inheritance with Stamps

about, Function Scope

closures, Lambdas, Closures–Closures, Partial Application and Currying, Fluent-Style JavaScript

encapsulating private data, Prototypal Inheritance with Stamps

hoisting, Hoisting–Closures

Function.prototype.bind() method, Function.prototype.bind(), Partial Application and Currying

Function.prototype.call() method, Method Context

functional enumerators, Lambdas

functional programming, First-Class Functions, Minimize Side Effects, Generics and Collection Polymorphism, Functional Programming–Functional Programming, Stateless Functions (aka Pure Functions)–Stateless Functions (aka Pure Functions), Partial Application and Currying, Partial Application and Currying, Conclusion

about, First-Class Functions, Functional Programming–Functional Programming, Conclusion

currying process, Partial Application and Currying

generic programming and, Generics and Collection Polymorphism

partial application, Partial Application and Currying

stateless functions, Minimize Side Effects, Stateless Functions (aka Pure Functions)–Stateless Functions (aka Pure Functions)

functional tests, Defining the App

functions, First-Class Functions, JSON: Data Storage and Communication, Functions, Minimize Side Effects–Minimize Side Effects, Function Definition–Function.prototype.bind(), Lambdas–Lambdas, Method Context, Function Scope–Closures, Method Design–Method Chaining and Fluent APIs, Function Polymorphism–Method dispatch, Function Polymorphism, Asynchronous Operations–Promises and Deferreds, Objects, Fluent-Style JavaScript, Fluent-Style JavaScript, Object Creation–Object Creation, Use One var Statement per Function, Use Functional Iterators When Possible–Use Functional Iterators When Possible

asynchronous operations, Asynchronous Operations–Promises and Deferreds

best practices, Use One var Statement per Function, Use Functional Iterators When Possible–Use Functional Iterators When Possible

constructor, Fluent-Style JavaScript, Object Creation–Object Creation

development guidelines, Functions

function definition, Function Definition–Function.prototype.bind()

function scope, Function Scope–Closures

invoking, Method Context

JavaScript advantages, First-Class Functions

JSON and, JSON: Data Storage and Communication

lambdas, Lambdas–Lambdas, Fluent-Style JavaScript

method design, Method Design–Method Chaining and Fluent APIs

minimizing side effects, Minimize Side Effects–Minimize Side Effects

as objects, Objects

polymorphic, Function Polymorphism–Method dispatch

sorting parameters, Function Polymorphism

G

Gamma, Erich, Who This Book Is Not For, Interfaces

Gang of Four, Who This Book Is Not For, Classical Inheritance Is Obsolete–Classical Inheritance Is Obsolete, Interfaces

gconf package, Configuration

generic programming, Generics and Collection Polymorphism–Generics and Collection Polymorphism

geofencing, Inherence factor

Geolocation API (HTML), Inherence factor

GET verb (HTTP), RESTful JSON Web Services, Logging Requests, Sample Log Output, Use common conventions, Resourceful routing

Globalize plug-in (Microsoft), Internationalization

Goodman, Danny, Events

Google Analytics, Logging Goals–Deciphering Data

Google Authenticator, Possession factor

Google Instant, Events

gorilla/banana problem, Classical Inheritance Is Obsolete

Grunt task runner, Bundling and Deployment–Bundling and Deployment, Templates

H

H-Factors, Affordances

HAProxy module, Optimizing for Speed

HATEOAS acronym, HATEOAS–HATEOAS

Helm, Richard, Who This Book Is Not For

Hickson, Ian, Web Components

higher order functions, First-Class Functions, Lambdas

hoisting (function scope), Hoisting–Closures

HTML, Inherence factor, HTML as an API Media Type

as API media type, HTML as an API Media Type

Geolocation API, Inherence factor

HTTP verbs, RESTful JSON Web Services–RESTful JSON Web Services, Logging Requests, Use common conventions, Resourceful routing

logging requests, Logging Requests

RESTful APIs and, RESTful JSON Web Services–RESTful JSON Web Services, Use common conventions, Resourceful routing

hypermedia, Self-Describing: Hypermedia, Affordances, HATEOAS–HATEOAS, HTML as an API Media Type, Jade–Jiron, Jiron–Jiron

about, Self-Describing: Hypermedia

affordances and, Affordances

HATEOAS acronym and, HATEOAS–HATEOAS

HTML and, HTML as an API Media Type

Jade template engine, Jade–Jiron

Jiron type, Jiron–Jiron

I

i18next library, Internationalization

IcoMoon app, Bundling and Deployment

if statement, Be Careful with if Statements–Be Careful with if Statements

IIFE (immediately invoked function expression), Immediately Invoked Function Expressions–Method Context, The Module Pattern

immediately invoked function expression (IIFE), Immediately Invoked Function Expressions–Method Context, The Module Pattern

import keyword, ES6 Modules

indentation (best practice), Indentation: Be Consistent

infrastructure diagram, Infrastructure–Infrastructure

inherence factor (authentication), Inherence factor

inheritance, Objects, Objects, Classical Inheritance Is Obsolete–Classical Inheritance Is Obsolete, Classical Inheritance Is Obsolete, Fluent-Style JavaScript, Prototypal Inheritance with Stamps–Prototypal Inheritance with Stamps, Web Components

classical, Objects, Classical Inheritance Is Obsolete–Classical Inheritance Is Obsolete

problems caused by, Classical Inheritance Is Obsolete

prototypal, Objects, Fluent-Style JavaScript, Prototypal Inheritance with Stamps–Prototypal Inheritance with Stamps, Web Components

interfaces in modular design, Interfaces–Interfaces

internalization process, Internationalization–Conclusion

J

Jade template engine, Jade–Jiron

Januska, Antonin, Defining the App

JavaScript, The JavaScript Revolution, Advantages of JavaScript–The Net Result, Anatomy of a Typical Modern JavaScript App–RESTful JSON Web Services, Fluent-Style JavaScript–Fluent-Style JavaScript, Example Tests, Code Quality, Best Practices Quick Reference–Don’t Use eval()

about, The JavaScript Revolution

advantages of, Advantages of JavaScript–The Net Result

anatomy of modern apps, Anatomy of a Typical Modern JavaScript App–RESTful JSON Web Services

best practices reference, Best Practices Quick Reference–Don’t Use eval()

code quality, Code Quality

example tests, Example Tests

fluent style, Fluent-Style JavaScript–Fluent-Style JavaScript

JavaScript Object Notation (JSON), Objects, JSON: Data Storage and Communication–JSON: Data Storage and Communication, RESTful JSON Web Services–RESTful JSON Web Services, Jiron

about, Objects

data storage and communication, JSON: Data Storage and Communication–JSON: Data Storage and Communication

Jiron comparison, Jiron

RESTful web services and, RESTful JSON Web Services–RESTful JSON Web Services

JavaScript: The Definitive Guide (Flannagan), Who This Book Is Not For

JavaScript: The Good Parts (Crockford), Who This Book Is Not For, JavaScript Style Guide

Jiron hypermedia type, Jiron–Jiron

Johnson, Ralph, Who This Book Is Not For

jQuery, Immediately Invoked Function Expressions, Named Parameters, Method dispatch, Generics and Collection Polymorphism, Method Chaining and Fluent APIs–Method Chaining and Fluent APIs, Callbacks, Promises and Deferreds–Promises and Deferreds, Fluent-Style JavaScript, Prototype Cloning, Interfaces, Asynchronous Module Definition, Feature Implementation, Client-Side Concerns, View events, Event delegation, Internationalization

.on() method, Callbacks

AMD support, Asynchronous Module Definition

collection polymorphism and, Generics and Collection Polymorphism

dynamic dispatch and, Method dispatch

.extend() method, Named Parameters, Prototype Cloning, Interfaces

fluent APIs, Method Chaining and Fluent APIs–Method Chaining and Fluent APIs

fluent style JavaScript and, Fluent-Style JavaScript

Globalize plug-in, Internationalization

IIFE, Immediately Invoked Function Expressions

microlibraries and, Client-Side Concerns

.on() method, Feature Implementation, View events, Event delegation

promises, Promises and Deferreds–Promises and Deferreds

JSLint, Best Practices Quick Reference

JSON (JavaScript Object Notation), Objects, JSON: Data Storage and Communication–JSON: Data Storage and Communication, RESTful JSON Web Services–RESTful JSON Web Services, Jiron

about, Objects

data storage and communication, JSON: Data Storage and Communication–JSON: Data Storage and Communication

Jiron comparison, Jiron

RESTful web services and, RESTful JSON Web Services–RESTful JSON Web Services

Jsonary client, Use common conventions

K

K-factor (viral factor), Viral Factor

Keep it Simple Stupid (KISS), Functions

Kestrel message queue, Queues and stacks

Key Performance Indicators (KPIs), Business Analytics

key stretching, Brute force

key/value pairs, as objects, Objects

KISS (Keep it Simple Stupid), Functions

KISSmetrics tool, Deciphering Data

knowledge factor (authentication), Knowledge factor

KPIs (Key Performance Indicators), Business Analytics

L

lambdas, Lambdas–Lambdas, Fluent-Style JavaScript

layers, defined, Separation of Concerns

Lee, Bruce, Classical Inheritance Is Obsolete, Fluent-Style JavaScript

Less is More guideline, Functions

let keyword, Function Scope

lifespan of features, Lifespan of a Feature, Development, Staging, Production Testing, Feature Rollout, Default Activation, Full Integration

about, Lifespan of a Feature

default activation phase, Default Activation

development phase, Development

full integration phase, Full Integration

production testing phase, Production Testing

rollout phase, Feature Rollout

staging phase, Staging

loader plug-ins, Plug-Ins–Plug-Ins

localization process, Internationalization

localStorage, Interfaces, Interfaces

logging, Logging, Debugging–Debugging, Server Operations, Security, Auditing, Business Analytics–Viral Factor, Logging Checklist, Logging Requests–Logging Requests, Logging Requests, Logging Errors–Sample Log Output, Sample Log Output–Sample Log Output, Logging Service Alerts, Logging Goals, Profiling and Instrumentation, Profiling and Instrumentation, Logging Client-Side Events, Deciphering Data

about, Logging

audit trails, Auditing

for business analytics, Business Analytics–Viral Factor

checklist considerations, Logging Checklist

client-side events, Logging Requests, Logging Client-Side Events

conversion goals, Logging Goals

debug messages, Debugging–Debugging

deciphering data, Deciphering Data

errors, Logging Errors–Sample Log Output

instrumenting code, Profiling and Instrumentation

profiling performance, Profiling and Instrumentation

sample output, Sample Log Output–Sample Log Output

security breaches, Security

server operations, Server Operations

server requests, Logging Requests–Logging Requests

service alerts, Logging Service Alerts

M

MAC (mandatory access control), Authorization

mandatory access control (MAC), Authorization

Math.random() method, Generics and Collection Polymorphism

MDN (Mozilla Developer Network), Use Functional Iterators When Possible

message queues, Queues and stacks

method chaining, Method Chaining and Fluent APIs

method delegation, Function Polymorphism

method dispatch, Method dispatch–Method dispatch

method literals, Function Definition

methods, Method Context–Function.prototype.bind(), Closures, Method Design, Named Parameters, Function Polymorphism–Method dispatch, Generics and Collection Polymorphism–Generics and Collection Polymorphism, Generics and Collection Polymorphism–Generics and Collection Polymorphism, Method Chaining and Fluent APIs–Method Chaining and Fluent APIs, Fluent-Style JavaScript, Factories–Prototypal Inheritance with Stamps, Interfaces

collection polymorphism, Generics and Collection Polymorphism–Generics and Collection Polymorphism

designing, Method Design

factory, Fluent-Style JavaScript, Factories–Prototypal Inheritance with Stamps, Interfaces

fluent APIs, Method Chaining and Fluent APIs–Method Chaining and Fluent APIs

function polymorphism, Function Polymorphism–Method dispatch

generic programming, Generics and Collection Polymorphism–Generics and Collection Polymorphism

invoking, Method Context–Function.prototype.bind()

named parameters, Named Parameters

privileged, Closures

Microjs.com website, Client-Side Concerns

microlibraries, Client-Side Concerns

Microsoft Globalize plug-in, Internationalization

middleware, Middleware–Let it crash

Milk, Chris, Events

Miraglia, Eric, The Module Pattern

Mixpanel tool, Deciphering Data

mobile devices, authentication and, Possession factor

model (MVC), Model View Controller/MV*

Model View Controller (MVC), Model View Controller/MV*–Model View Controller/MV*

Model View Presenter (MVP), Model View Controller/MV*

module pattern, The Module Pattern–The Module Pattern

module() function, QUnit Primer

modules, Modules, Principles of Modularity, Interfaces–Interfaces, The Module Pattern–The Module Pattern, Asynchronous Module Definition–Plug-Ins, Node-Style Modules–Node-Style Modules, npm–npm, ES6 Modules, Building Client-Side Code with CommonJS, npm, Grunt, and Browserify–Bundling and Deployment, Separation of Concerns, Module Management–Registration, loading, and rendering

about, Modules

AMD support, Asynchronous Module Definition–Plug-Ins

building client-side code, Building Client-Side Code with CommonJS, npm, Grunt, and Browserify–Bundling and Deployment

design principles, Principles of Modularity

ES6, ES6 Modules

interfaces and, Interfaces–Interfaces

managing, Module Management–Registration, loading, and rendering

module pattern, The Module Pattern–The Module Pattern

node style, Node-Style Modules–Node-Style Modules

npm support, npm–npm

separation of concerns, Separation of Concerns

Moment.js library, Internationalization

MongoDB data stores, NoSQL Data Stores

Monthly Recurring Revenue (MRR), Business Analytics

Mozilla Developer Network (MDN), Use Functional Iterators When Possible

Mozilla Persona, Mozilla Persona

MRR (Monthly Recurring Revenue), Business Analytics

multifactor authentication, Multifactor Authentication, Knowledge factor, Possession factor, Inherence factor

about, Multifactor Authentication

inherence factor, Inherence factor

knowledge factor, Knowledge factor

possession factor, Possession factor

MVC (Model View Controller), Model View Controller/MV*–Model View Controller/MV*

MVP (Model View Presenter), Model View Controller/MV*

N

name collisions (best practice), Avoid Name Collisions

named function expressions, Named Function Expressions–Lambdas

named parameters (methods), Named Parameters

namespaces, Method Context, Fluent-Style JavaScript, The Module Pattern, Avoid Name Collisions

best practices, Avoid Name Collisions

common mistakes, The Module Pattern

this keyword and, Method Context, Fluent-Style JavaScript

new keyword, Fluent-Style JavaScript, Delegate Prototypes

New Relic tool, Profiling and Instrumentation, Optimizing for Speed

Node environment, Getting Started with Node and Express–Getting Started with Node and Express, Installing Node and Express, Organizing files in Node, Node libraries, Configuration, Next steps

about, Getting Started with Node and Express–Getting Started with Node and Express, Next steps

configuration considerations, Configuration

installing, Installing Node and Express

libraries supported, Node libraries

organizing files in, Organizing files in Node

node package manager (npm), npm–npm

Node Version Manager (nvm), Installing Node and Express

Node.js, Performance, Conclusion, Password salts

performance advantages, Performance

random generators, Password salts

Stampit and, Conclusion

Nodetime tool, Profiling and Instrumentation

NoSQL data stores, Infrastructure, NoSQL Data Stores

npm (node package manager), npm–npm

nvm (Node Version Manager), Installing Node and Express

O

OAuth 2.0 standard, OAuth 2.0

Object constructor, Delegate Prototypes–Delegate Prototypes, Delegate Prototypes–Delegate Prototypes, Prototype Cloning, Prototypal Inheritance with Stamps, Prototypal Inheritance with Stamps, Interfaces

assign() method, Prototype Cloning

create() method, Delegate Prototypes–Delegate Prototypes, Prototypal Inheritance with Stamps, Prototypal Inheritance with Stamps, Interfaces

prototype property, Delegate Prototypes–Delegate Prototypes

object literal notation, Objects, Syntax, JSON: Data Storage and Communication, Fluent-Style JavaScript, Object Creation

about, Fluent-Style JavaScript

JSON and, Objects, Syntax, JSON: Data Storage and Communication

object creation example, Object Creation

object-oriented design, Classical Inheritance Is Obsolete, Classical Inheritance Is Obsolete–Classical Inheritance Is Obsolete, Classical Inheritance Is Obsolete

foundational principles, Classical Inheritance Is Obsolete

gorilla/banana problem, Classical Inheritance Is Obsolete

on inheritance, Classical Inheritance Is Obsolete–Classical Inheritance Is Obsolete

objects, Objects, Objects, Generics and Collection Polymorphism, Method Chaining and Fluent APIs, Promises and Deferreds–Promises and Deferreds, Objects, Fluent-Style JavaScript–Fluent-Style JavaScript, Fluent-Style JavaScript, Fluent-Style JavaScript–The Flyweight Pattern, Fluent-Style JavaScript, Object Creation–Object Creation, Factories–Prototypal Inheritance with Stamps, Prototypal Inheritance with Stamps–Prototypal Inheritance with Stamps, Prototypal Inheritance with Stamps–Prototypal Inheritance with Stamps

about, Objects

as collections, Generics and Collection Polymorphism

creating, Object Creation–Object Creation, Prototypal Inheritance with Stamps–Prototypal Inheritance with Stamps

factory methods, Fluent-Style JavaScript, Factories–Prototypal Inheritance with Stamps

fluent APIs and, Method Chaining and Fluent APIs

fluent style JavaScript and, Fluent-Style JavaScript–Fluent-Style JavaScript

JavaScript advantages, Objects

promises and deferreds, Promises and Deferreds–Promises and Deferreds

prototypal inheritance, Objects, Fluent-Style JavaScript, Prototypal Inheritance with Stamps–Prototypal Inheritance with Stamps

prototypes, Fluent-Style JavaScript–The Flyweight Pattern

ok() function, QUnit Primer

One Hour Translation service, Conclusion

one-time passwords (OTPs), Possession factor

Open Closed Principle, Principles of Modularity

OpenID, Federated and Delegated Authentication, OAuth 2.0

optimizing for speed (design principle), Optimizing for Speed

Osmani, Addy, Module Management

OTPs (one-time passwords), Possession factor

P

parameters, Named Parameters, Function Polymorphism

named, Named Parameters

sorting, Function Polymorphism

parametric polymorphism, Generics and Collection Polymorphism

parentheses (), Method Context

partial application, Partial Application and Currying

password salts, Password salts

passwords, Passwords, Passwords, Rainbow tables, Password salts, Brute force–Brute force, Variable time equality, Stolen passwords

about, Passwords

brute force attacks, Brute force–Brute force

password salts, Password salts

rainbow tables, Rainbow tables

stolen, Stolen passwords

variable time equality, Variable time equality

vulnerability of, Passwords

performance, Performance, Profiling and Instrumentation

JavaScript advantages, Performance

profiling, Profiling and Instrumentation

Persona (Mozilla), Mozilla Persona

plug-ins (loader), Plug-Ins–Plug-Ins

Polymer website, Web Components

polymorphism, Function Polymorphism–Method dispatch, Generics and Collection Polymorphism–Generics and Collection Polymorphism, Generics and Collection Polymorphism, Generics and Collection Polymorphism

ad-hoc, Generics and Collection Polymorphism

collection, Generics and Collection Polymorphism–Generics and Collection Polymorphism

function, Function Polymorphism–Method dispatch

parametric, Generics and Collection Polymorphism

possession factor (authentication), Possession factor

POST verb (HTTP), RESTful JSON Web Services–RESTful JSON Web Services, Logging Requests, Use common conventions, Resourceful routing

primitive types, Objects

private data, encapsulation and, Object Creation, Factories–Factories, Prototypal Inheritance with Stamps

privileged methods, Closures

production testing phase (feature-toggle), Production Testing

promises (objects), Promises and Deferreds–Promises and Deferreds

prototypal inheritance, Objects, Fluent-Style JavaScript, Prototypal Inheritance with Stamps–Prototypal Inheritance with Stamps, Web Components

about, Objects, Fluent-Style JavaScript

custom tags and, Web Components

with stamps, Prototypal Inheritance with Stamps–Prototypal Inheritance with Stamps

prototype chain, Objects, Delegate Prototypes

Prototype library, Fluent-Style JavaScript

prototypes, Fluent-Style JavaScript–Prototypes, Delegate Prototypes–Delegate Prototypes, Prototype Cloning–Prototype Cloning, The Flyweight Pattern–The Flyweight Pattern, Prototypal Inheritance with Stamps

about, Fluent-Style JavaScript–Prototypes

cloning, Prototype Cloning–Prototype Cloning

delegate, Delegate Prototypes–Delegate Prototypes, Prototypal Inheritance with Stamps

flyweight pattern, The Flyweight Pattern–The Flyweight Pattern

publish_actions permission, Authorizing Applications

pure functions, Minimize Side Effects, Stateless Functions (aka Pure Functions)–Stateless Functions (aka Pure Functions)

PUT verb (HTTP), RESTful JSON Web Services–RESTful JSON Web Services, Use common conventions, Resourceful routing

Q

QUnit framework, Closures, Closures, Closures, Closures, Defining the App–Defining the App, Bundling and Deployment, Example Tests, QUnit Primer, QUnit Primer, QUnit Primer, QUnit Primer

about, Example Tests

asyncTest() function, Closures

client-side code and, Defining the App–Defining the App

equal() function, Closures, QUnit Primer

module() function, QUnit Primer

ok() function, QUnit Primer

start() function, Closures

stop() function, Closures

task output example, Bundling and Deployment

test() function, QUnit Primer

R

rainbow tables, Rainbow tables

random generators, Password salts

RBACs (role-based access controls), Authorization

RDBMS (Relational Database Management System), Infrastructure, NoSQL Data Stores

.reject() method, Promises and Deferreds

Relational Database Management System (RDBMS), Infrastructure, NoSQL Data Stores

remote procedure calls (RPCs), Use common conventions

Representational State Transfer (REST), RESTful JSON Web Services–RESTful JSON Web Services

representations, Minimize Side Effects

request serializers, Logging Requests–Logging Requests

require() function, Node-Style Modules

Require.js, Plug-Ins

.resolve() method, Promises and Deferreds

resources, defined, Resourceful routing

responsive (design principle), Responsive APIs–Responsive APIs

REST (Representational State Transfer), RESTful JSON Web Services–RESTful JSON Web Services

RESTful APIs, RESTful JSON Web Services, Building RESTful APIs–Building RESTful APIs, Usable–Resourceful routing, Use common conventions, Resourceful routing, Self-Describing: Hypermedia–Jiron, Responsive APIs–Responsive APIs, Optimizing for Speed

building, Building RESTful APIs–Building RESTful APIs

HTTP verbs and, RESTful JSON Web Services, Use common conventions, Resourceful routing

optimizing for speed, Optimizing for Speed

responsive, Responsive APIs–Responsive APIs

self-describing, Self-Describing: Hypermedia–Jiron

usable, Usable–Resourceful routing

retina scanners, Inherence factor

reusability in code development, Reusability

Riot.js library, Model View Controller/MV*

role-based access controls (RBACs), Authorization

rollout phase (feature-toggle), Feature Rollout

routing, Routing, Resourceful routing–Resourceful routing

Express framework support, Routing

resourceful, Resourceful routing–Resourceful routing

RPCs (remote procedure calls), Use common conventions

S

SaaS (Software as a Service), Business Analytics

salting passwords, Password salts

Satrom, Brandon, Building RESTful APIs

scope (function), Function Scope, Function Scope (see function scope)

security, Authentication–Delegated authentication, Authorization–OAuth 2.0, Conclusion, Security

authentication, Authentication–Delegated authentication

authorization, Authorization–OAuth 2.0

logging breaches, Security

recommendations, Conclusion

self-describing (design principle), Self-Describing: Hypermedia, Affordances, HATEOAS–HATEOAS, HTML as an API Media Type, Jade–Jiron, Jiron–Jiron

about, Self-Describing: Hypermedia

affordances and, Affordances

HATEOAS acronym and, HATEOAS–HATEOAS

HTML and, HTML as an API Media Type

Jade template engine, Jade–Jiron

Jiron type, Jiron–Jiron

self-invoked anonymous functions, Immediately Invoked Function Expressions

semantic versioning, npm

semicolons (best practice), Use Semicolons

separation of concerns, Separation of Concerns, Client-Side Concerns–Web Components, Module Management–Registration, loading, and rendering, Events–Events by example, Model View Controller/MV*–Model View Controller/MV*, Presentation and DOM Manipulation–Web Components, Presentation and DOM Manipulation–Web Components, Server-Side Concerns–Next steps, Don’t Use switch

about, Separation of Concerns

application presentation, Presentation and DOM Manipulation–Web Components

best practices, Don’t Use switch

client-side concerns, Client-Side Concerns–Web Components

DOM manipulation, Presentation and DOM Manipulation–Web Components

events, Events–Events by example

module management, Module Management–Registration, loading, and rendering

MVC architecture, Model View Controller/MV*–Model View Controller/MV*

server-side concerns, Server-Side Concerns–Next steps

serializers, request, Logging Requests–Logging Requests

server-side operations, Node-Style Modules–Node-Style Modules, Server-Side Concerns, Server Operations, Logging Requests–Logging Requests

logging server operations, Server Operations

logging server requests, Logging Requests–Logging Requests

node style modules, Node-Style Modules–Node-Style Modules

separation of concerns, Server-Side Concerns

service alerts, logging, Logging Service Alerts

shadow DOM, Web Components–Web Components

shims, defined, Use Functional Iterators When Possible

Shore, James, Defining the App

side effects, Minimize Side Effects–Minimize Side Effects, Avoid Side Effects–Don’t Use switch

best practices, Avoid Side Effects–Don’t Use switch

minimizing, Minimize Side Effects–Minimize Side Effects

Siebel, Peter, Classical Inheritance Is Obsolete

Simple Queue Service (SQS), Queues and stacks

single sign on (SSO), Federated and Delegated Authentication

snapshots of virtual machines, Security

Snook, Jonathan, Bundling and Deployment

Software as a Service (SaaS), Business Analytics

sorting parameters, Function Polymorphism

speakeasy module, Possession factor

Splunk tool, Deciphering Data

SQL (Structured Query Language), Infrastructure

SQS (Simple Queue Service), Queues and stacks

square bracket notation, Method Context, Function Polymorphism

SSO (single sign on), Federated and Delegated Authentication

stack trace, Logging Errors

staging phase (feature-toggle), Staging

Stampit library, Prototypal Inheritance with Stamps–Conclusion, Prototypal Inheritance with Stamps, Prototypal Inheritance with Stamps, Prototypal Inheritance with Stamps, Prototypal Inheritance with Stamps, Interfaces, Interfaces, Interfaces, Interfaces, Interfaces

about, Prototypal Inheritance with Stamps–Conclusion

.compose() method, Prototypal Inheritance with Stamps, Interfaces, Interfaces, Interfaces

defining factory, Interfaces

.enclose() method, Prototypal Inheritance with Stamps

.methods() method, Prototypal Inheritance with Stamps, Interfaces

.state() method, Prototypal Inheritance with Stamps

stamps, Prototypal Inheritance with Stamps–Prototypal Inheritance with Stamps

start() function, Closures

stateless functions, Minimize Side Effects, Stateless Functions (aka Pure Functions)–Stateless Functions (aka Pure Functions)

stolen passwords, Stolen passwords

stop() function, Closures

storage, data, JSON: Data Storage and Communication–NoSQL Data Stores

Structured Query Language (SQL), Infrastructure

subclassing, Classical Inheritance Is Obsolete, Fluent-Style JavaScript, Model View Controller/MV*

switch statement, Don’t Use switch–Don’t Use switch

syntax (JavaScript), Syntax

T

The Tao of Jeet Kun Do (Lee), Fluent-Style JavaScript

TDD (test-driven development), Defining the App

templates, Templates–Templates, Templates, Jade–Jiron

about, Templates–Templates

Express framework support, Templates

Jade template engine, Jade–Jiron

test() function, QUnit Primer

test-driven development (TDD), Defining the App

testing, Defining the App, Defining the App, Production Testing, Example Tests

eliminating false positives, Defining the App

features, Production Testing

functional tests, Defining the App

JavaScript example tests, Example Tests

Tethras service, Conclusion

text! plug-in, Plug-Ins

this keyword, Method Context, Fluent-Style JavaScript

tiers, defined, Separation of Concerns

timing attacks, Variable time equality

Tinyapp module management, Module Management–Registration, loading, and rendering, Events by example–Events by example

TodoMVC project, Client-Side Concerns, Model View Controller/MV*

Twitter, Defining the App, Delegated authentication

authentication and, Delegated authentication

Bootstrap framework, Defining the App

U

UMD (universal module definition), Asynchronous Module Definition

Underscore library, First-Class Functions, Named Parameters, Generics and Collection Polymorphism, Prototype Cloning, Event aggregators, Templates–Templates

about, First-Class Functions

collection polymorphism and, Generics and Collection Polymorphism

event aggregators and, Event aggregators

.extend() method, Named Parameters, Prototype Cloning

template support, Templates–Templates

Unicode CLDR, Internationalization

Uniform Resource Indicator (URI), RESTful JSON Web Services

universal module definition (UMD), Asynchronous Module Definition

URI (Uniform Resource Indicator), RESTful JSON Web Services

usability (design principle), Usable–Focus, Usable, Consistency–Resourceful routing

consistency, Usable, Consistency–Resourceful routing

focus, Usable–Focus

user stories, Defining the App

V

van Straaten, Anton, Conclusion

var keyword, Function Scope, Always Use var

Venners, Bill, Interfaces

view (MVC), Model View Controller/MV*, Presentation and DOM Manipulation

viral factor (K-factor), Viral Factor

virtual machines, snapshots of, Security

Virtual Private Networks (VPNs), Infrastructure

Vlissides. John, Who This Book Is Not For

VPNs (Virtual Private Networks), Infrastructure

W

Web Components, Web Components–Web Components

WebID, WebID

widgets, defined, Separation of Concerns

The Wilderness Downtown (film), Events

X

X-HTTP-Method-Override header, Use common conventions

XML (Extensible Markup Language), NoSQL Data Stores

XMLHttpRequest object, The JavaScript Revolution

Xstyle framework, Plug-Ins

Y

YUI blog, The Module Pattern

Z

Zakas, Nicholas, Module Management