Book Image

Building Enterprise JavaScript Applications

By : Daniel Li
Book Image

Building Enterprise JavaScript Applications

By: Daniel Li

Overview of this book

With the over-abundance of tools in the JavaScript ecosystem, it's easy to feel lost. Build tools, package managers, loaders, bundlers, linters, compilers, transpilers, typecheckers - how do you make sense of it all? In this book, we will build a simple API and React application from scratch. We begin by setting up our development environment using Git, yarn, Babel, and ESLint. Then, we will use Express, Elasticsearch and JSON Web Tokens (JWTs) to build a stateless API service. For the front-end, we will use React, Redux, and Webpack. A central theme in the book is maintaining code quality. As such, we will enforce a Test-Driven Development (TDD) process using Selenium, Cucumber, Mocha, Sinon, and Istanbul. As we progress through the book, the focus will shift towards automation and infrastructure. You will learn to work with Continuous Integration (CI) servers like Jenkins, deploying services inside Docker containers, and run them on Kubernetes. By following this book, you would gain the skills needed to build robust, production-ready applications.
Table of Contents (26 chapters)
Title Page
Copyright and Credits
Dedication
Packt Upsell
Contributors
Preface
Free Chapter
1
The Importance of Good Code
Index

Index

A

  • Acceptance Test-Driven Development (ATDD) / Test-Driven Development
  • acceptance tests / Understanding different types of test
  • Advanced Packaging Tool (APT) / Setting up Git
  • AJAX (Asynchronous JavaScript And XML) / Implementing step definitions
  • alternatives, VPS
    • private networking / Selecting additional options
    • IPv6 / Selecting additional options
    • monitoring / Selecting additional options
  • Amazon Web Services (AWS) / Exploring the Secure Remote Password (SRP) protocol
  • AMD / The dawn of modules
  • analytics engine / Introduction to Elasticsearch
  • AngularJS/Angular / Vanilla JavaScript vs. frameworks
  • Annual Percentage Rate (APR) / The debt spiral
  • Apache Lucene / Introduction to Elasticsearch
  • Apache Solr / Introduction to Elasticsearch
  • API
    • designing / Designing our API
    • consistency / Consistent
    • intuitive design / Intuitive
    • Keep It Simple Stupid (KISS) / Keep It Simple Stupid (KISS)
    • completing / Completing our API
    • executing / Running our API
    • executing, with PM2 / Keeping our API alive with PM2
    • executing, on port 80 / Running our API on port 80
    • documentation, deploying / Deployment
  • API description language / Overview of OpenAPI and Swagger
  • API specification
    • defining, with OpenAPI / Defining an API specification with OpenAPI
  • application-specific integrated circuit chips (ASICs) / Hash stretching algorithms
  • Asynchronous Module Definition (AMD) / AMD and Require.js
  • asynchronous module loading
    • about / Standardizing module formats, Asynchronous module loading
    • Asynchronous Module Definition (AMD) / AMD and Require.js
    • Require.js / AMD and Require.js
    • Universal Module Definition (UMD) / Universal Module Definition
  • Aurelia / Choosing a framework/library
  • authentication / What is Authentication?
  • authentication type / The Authorization header
  • Authorization header / The Authorization header
  • automated UI testing / Automated UI testing
  • automation server / Introduction to Jenkins
  • AVA
    • URL / Picking a testing framework
  • axios
    • URL / Implementing step definitions

B

  • Babel
    • about / Standardizing module formats, Transpiling ES6 with Babel, Babel is a transpiler...and more!
    • ES6, transpiling / Transpiling ES6 with Babel
    • using / Different faces of Babel
    • @babel/cli / @babel/cli
    • @babel/register / @babel/register
    • @babel/register, using for tests / Using @babel/register for tests
    • @babel/node / @babel/node
    • @babel/core / @babel/core
    • @babel/polyfill / @babel/polyfill
    • Babel CLI, adding / Adding Babel CLI and polyfill
    • polyfill, adding / Adding Babel CLI and polyfill
    • Babel code, used fo transpiling code / Using Babel CLI to transpile our code
    • plugins / Plugins and presets
    • presets / Plugins and presets
    • env preset / The env preset
    • distribution code / Separating source and distribution code
    • source, separating / Separating source and distribution code
    • polyfill, importing / Importing the Babel polyfill
  • babel-plugin-rewire
    • URL / Monkey patching
  • Babel transpiler / Transpiling JSX
  • Backbone / Choosing a framework/library
  • backend API, E2E tests
    • running / Running our backend API
    • dynamic string substitution, with Webpack / Dynamic string substitution with Webpack
    • API, serving from submodule / Serving the API from a submodule
    • happy scenario, defining / Defining the happy scenario
    • random data, generating / Generating random data
    • generic step definitions / Making step definitions more generic
    • clicking / Clicking
    • waiting / Waiting
    • component, rendering based on state / Render components based on state
  • backend API deployment
    • about / Deploying the backend API
    • image, publishing to Docker Hub / Publishing our image to Docker Hub
    • creating / Creating a Deployment
    • services, discovering with kube-dns/CoreDNS / Discovering Services using kube-dns/CoreDNS
    • running / Running Our backend Deployment
  • backend Service
    • creating / Creating a backend Service
  • bcryptjs library
    • reference / Picking a bcrypt library
    • using / Using the bcryptjs library
  • bcrypt library
    • about / Hash stretching algorithms
    • selecting / Picking a bcrypt library
  • Behavior-Driven Development (BDD) / Test-Driven Development, Understanding different types of test
  • best practices, Dockerfile
    • shell, versus exec forms / Shell versus exec forms
    • lighter image, using / Using a lighter image
    • obsolete files, removing / Removing obsolete files
    • multi-stage builds / Multi-stage builds
    • security / Security
  • block cipher / Block cipher
  • body-parser middleware
    • using / Using body-parser middleware
    • E2E test, executing / Run E2E test
  • branches merging
    • about / Merging branches
    • merge, using with rebase / Using merge and rebase together
  • branching model
    • about / Branching models
    • Driessen model / The Driessen model
    • development branch, creating / Creating a development branch
    • feature branches, creating / Creating feature branches
    • realistic examples, examining / Examining more realistic examples
    • dev Branch Bug-Free / Keeping the dev Branch Bug-Free
    • history, cleaning / Keeping our history clean
    • history cleaning, with git rebase / Keeping our history clean with git rebase
    • history, cleaning with git rebase / Keeping our history clean with git rebase
  • breakpoints / Using a debugger for Node.js debugging
  • brownfield projects /
  • browser drivers / Browser drivers
  • Browserify / Shared code, Browserify
  • browser testing / Browser testing
  • brute-force attacks
    • preventing, against single user / Preventing brute-force attacks against a single user
    • about / Preventing brute-force attacks against a single user
    • protecting against / Protecting against brute-force attacks
  • BuildBot / Picking a CI server
  • business requirements / Gathering business requirements

C

  • cache / The three tracked states
  • caching server / What is REST?
  • capabilities
    • setting / Setting capabilities
  • catch-all record / A and AAAA
  • Certbot
    • reference / Preventing man-in-the-middle (MITM) attacks
    • about / Preventing man-in-the-middle (MITM) attacks
  • Certificate Authority (CA) / Preventing man-in-the-middle (MITM) attacks
  • ciphertext / Block cipher
  • CI server
    • selecting / Picking a CI server
    • pros and cons / Picking a CI server
  • cL7 load balancer / Layer 7 load balancing
  • claims, JSON web token (JWT)
    • about / Payload and claims
    • registered claim names / Registered claim names
    • public claim names / Public claim names
    • private claim name / Private claim names
    • example claim / Example claim
  • client-side frameworks/libraries
    • selecting / Choosing a framework/library
  • client-side modules
    • about / Client-side modules
    • bundling / Module bundling
  • client-side web application framework / Single page applications (SPAs)
  • cloneDeep method
    • URL / Asserting deep equality
  • Closure compiler / Transpiling ES6 with Babel
  • cloud provider deployment
    • about / Deploying on cloud provider
    • new remote cluster, creating / Creating a new remote cluster
    • contexts, switching / Switching contexts
  • cluster
    • about / What is REST?, Clusters and microservices, Clusters
    • creating / Creating our cluster
    • environment variables, setting for local cluster / Setting environment variables for the local cluster
    • minikube start, running / Running minikube start
    • context, updating / Updating the context
    • resetting / Resetting the cluster
  • cluster-level tools
    • about / Cluster management, Cluster-level tools
    • scheduler / Cluster management, Scheduler
    • Discovery Service / Cluster management, Discovery service
    • Global Configuration Store / Cluster management, Global configuration store
    • provisioning tools / Provisioning tools
  • cluster management
    • about / Cluster management
    • cluster-level tools / Cluster management
    • node-level / Cluster management
  • Cluster Management Tool
    • picking / Picking a cluster management tool
    • Marathon / Picking a cluster management tool
    • Swarm / Picking a cluster management tool
    • Kubernetes / Picking a cluster management tool
  • code
    • releasing / Releasing code
    • modularizing / Modularizing our code
  • code reusability / Modules
  • code splitting / Isomorphic JavaScript applications, Webpack
  • CoffeeScript / Transpiling JSX
  • command-line interface (CLI) / Setting up Git
  • commands, running on multiple servers
    • about / Running commands on multiple servers
    • pssh, using / Using pssh
    • init containers, using / Using init containers
  • Commit Status API
    • reference / Examining Travis CI results
  • committing / Configuring a user
  • CommonJS / The dawn of modules
  • common language runtime (CLR) / What is Node.js?
  • compiled languages / What is Node.js?
  • components
    • Redux, decoupling / Decoupling Redux from components
    • about / Control Planes and components
  • components, React
    • root component / Components
    • child component / Components
    • functional components / Functional and class components
    • class components / Functional and class components
    • pure components / Pure components
  • concurrent updates / Understanding indices, types, documents, and versions
  • Configuration-as-Code (CaC) / Pipeline
  • consistency, API
    • about / Consistent, Common consistency
    • HTTP status code, sending / Sending the correct HTTP status code
    • HTTP methods, using / Using HTTP methods
    • ISO formats, using / Using ISO formats
    • local consistency / Local consistency
    • naming convention / Naming convention
    • consistent data exchange format / Consistent data exchange format
    • error response payload / Error response payload
    • transversal consistency / Transversal consistency
    • domain consistency / Domain consistency
    • perennial consistency / Perennial consistency
    • modifications, breaking in APIs / Breaking changes in APIs
    • URL, future-proofing / Future-proofing your URL
    • data structure, future-proofing / Future-proofing your data structure
    • versioning / Versioning
  • container / Setting up the environment
  • container runtime / Container runtime
  • context
    • about / Understanding NGINX's configuration file
  • context switching
    • about / Benefits of Node.js, Context switching
    • projects, switching / Switching between projects
    • languages, switching between / Switching between languages
    • business perspective / The business perspective
  • Continuous Integration (CI)
    • about / Continuous Integration (CI)
    • with Jenkins / Continuous Integration with Jenkins
  • controlled form elements / Controlled form elements
  • Controllers
    • about / Controllers
    • Node Controller / Controllers
    • Replication Controller / Controllers
    • Volume Controller / Controllers
    • Route Controller / Controllers
    • Service Controller / Controllers
    • Endpoints Controller / Controllers
    • Service Account and Token Controllers / Controllers
  • Cordova / Hybrid applications with Ionic
  • Create User endpoint
    • specifying / Specifying the Create User endpoint
  • Cross-Origin Resource Sharing (CORS)
    • enabling / Enabling CORS
    • same-origin policy / Same-origin policy
    • about / Cross-Origin Resource Sharing (CORS)
  • Cross-Site Request Forgery (CSRF) attack
    • about / Cross-Site Request Forgery (XSRF), Same-origin policy
    • reference / Cross-Site Request Forgery (XSRF)
  • Cross-Site Scripting (XSS)
    • about / Cross-Site Scripting (XSS)
    • reference / Cross-Site Request Forgery (XSRF)
  • CruiseControl / Picking a CI server
  • cryptographic hashing algorithm
    • about / Cryptographic hash functions
    • properties / Cryptographic hash functions
    • selecting / Picking a cryptographic hashing algorithm
    • hash stretching / Hash stretching
    • hash stretching algorithms / Hash stretching algorithms
  • CSI-DigitalOcean
    • URL / Using the csi-digitalocean provisioner
  • CSS preprocessors / JSX
  • Cucumber
    • E2E tests, setting up / Setting Up E2E tests with Cucumber
    • features / Features, scenarios, and steps
    • steps / Features, scenarios, and steps
    • Gherkin keywords / Gherkin keywords
    • feature, specifying / Specifying our feature
    • scenario, writing / Writing our first scenario
    • step definitions, laying out / Laying out our step definitions
    • scenarios, executing / Running our scenarios

D

  • data persisting
    • about / Persisting data
    • Kubernetes Volumes / Introducing Kubernetes Volumes
  • data type
    • validating / Validating data type
    • tests, refactoring / Refactoring our tests
    • scenario outlines, using / Using scenario outlines
    • duplicate step definitions, combining / Combining duplicate step definitions
    • application, refactoring / Refactoring our application
    • framework, selecting / Choosing a framework
  • debugger / Using a debugger for Node.js debugging
  • declarative approach
    • deployment, deleting / Deleting deployment
    • deployment manifest, creating / Creating a deployment manifest
  • declarative pipeline
    • versus scripted pipeline / Declarative versus scripted pipelines
    • about / The declarative pipeline
  • decorators / MobX
  • delimiters / Naming sub-branches
  • denormalize / Elasticsearch versus other distributed document store
  • dependency injection (DI) / Stubbing create, Dependency injection
  • dependency injection, versus monkey patching
    • about / Dependency injection versus monkey patching
    • modularity / Modularity
    • readability / Readability
    • third-party tools reliability / Reliance on third-party tools
  • deterministic random bit generator (DRBG) / Generating a salt for non-existent users
  • development dependencies / Adding Babel CLI and polyfill
  • DevTools Protocol / Using ndb
  • dictionary attacks / Preventing brute-force attacks against a single user
  • digest cycle / Learning curve
  • digests
    • about / Hashing passwords
    • encrypting / Encrypting digests
  • DigitalOcean (DO)
    • URL / Setting up a Virtual Private Server (VPS)
    • about / Using the csi-digitalocean provisioner
  • digital signature / Anatomy of a JWT, Signature
  • directives
    • block / Understanding NGINX's configuration file
    • simple / Understanding NGINX's configuration file
  • distributed database / Introduction to Elasticsearch
  • DNS load balancing / DNS load balancing
  • Docker
    • installing / Installing Docker, Installing Docker
    • about / Introduction to Docker
    • containers / What are containers?
    • workflow / Workflow
    • used, for solving issues / How does Docker solve our issues?
    • benefits / How does Docker solve our issues?
    • mechanics / Mechanics of Docker
    • Community Edition (CE) / Setting up the Docker Toolchain
    • Enterprise Edition (EE) / Setting up the Docker Toolchain
    • Elasticsearch, running on / Running Elasticsearch on Docker 
  • Docker container
    • reference / Installing Jenkins
    • about / What is a Docker container?
    • control groups / Control groups
    • namespaces / Namespaces
    • LXC and Docker / LXC and Docker
    • virtual machines / Virtual Machines
    • comparing, with VMs / Containers versus Virtual Machines
    • running / Running a container, Running a container
  • Docker Engine
    • about / Docker Engine, Daemon, and Client
    • Docker daemon / Docker Engine, Daemon, and Client
    • Docker client / Docker Engine, Daemon, and Client
  • Dockerfile
    • overview / Overview of a Dockerfile
    • writing / Writing our Dockerfile
    • base image, picking / Picking a base image
    • project files, copying / Copying project files
    • application, building / Building our application
    • executable, specifying / Specifying the executable
    • best practices / Following best practices
    • Unix signaling, allowing / Allowing Unix signaling
    • running, as non-root user / Running as a non-root user
    • cache, taking advantage of / Taking advantage of the cache
    • caveats / Caveats
  • Docker image
    • about / What is a Docker image?
    • layers / Images are layered
    • Docker Toolchain, setting up / Setting up the Docker Toolchain
    • Docker package repository, adding / Adding the Docker package repository
    • building / Building our image
    • running / Running our image
    • data, persisting / Persisting data
  • Docker Machine / Installing a Hypervisor or Docker Machine
  • docker run option
    • about / Understanding the docker run option
    • container, identifying by name / Identifying a container by name 
    • environment variables, setting / Setting environment variables
    • running, as daemon / Running as daemon
    • network port mapping / Network port mapping, 0.0.0.0
    • test script, updating / Updating our test script
    • backend API, Dockerizing / Dockerizing our backend API
    • Dockerfile / Overview of a Dockerfile
  • Document Object Model (DOM) / How Virtual DOM improves performance
  • domain-level nameserver / Understanding DNS
  • domain consistency / Domain consistency
  • Domain Name System (DNS)
    • about / From IP to domain, Understanding DNS
    • domain, buying / Buying a domain
    • updating / Updating the domain nameserver
    • zone file, building / Building our zone file
    • NS records / NS records
    • A records / A and AAAA
    • AAAA records / A and AAAA
    • Start of Authority (SOA) / Start of Authority (SOA)
    • NGINX, updating / Updating NGINX
  • Domain Specific Language (DSL) / Setting Up E2E tests with Cucumber, Pipeline
  • Don't Repeat Yourself (DRY) principle / Shared code
  • Driessen model / The Driessen model
  • Dyn
    • URL / Managed DNS
  • dynamic mapping
    • about / Rejecting additional properties
    • URL / Dynamic mapping in Elasticsearch
  • dynamic volume provisioning
    • with StorageClass / Dynamic volume provisioning with StorageClass

E

  • E2E/functional tests / Understanding different types of test
  • Ecma International / Standardizing module formats
  • Elasticsearch
    • about / Introduction to Elasticsearch
    • versus distributed document store / Elasticsearch versus other distributed document store
    • installing / Installing Java and Elasticsearch, Installing and starting Elasticsearch
    • initializing / Installing and starting Elasticsearch
    • key concepts / Understanding key concepts in Elasticsearch
    • JSON document store / Elasticsearch is a JSON document store
    • document, versus relationship data storage / Document vs. relationship data storage
    • indices / Understanding indices, types, documents, and versions
    • types / Understanding indices, types, documents, and versions
    • documents / Understanding indices, types, documents, and versions
    • versions / Understanding indices, types, documents, and versions
    • querying, from E2E tests / Querying Elasticsearch from E2E tests
    • documents, indexing / Indexing documents to Elasticsearch
    • test user, deleting / Deleting our test user
    • testing experience, enhancing / Improving our testing experience
    • tests, executing in test database / Running tests in a test database
    • development server, separating from testing server / Separating development and testing servers
    • standalone E2E test script, creating / Making a standalone E2E test script
    • shebang interpreter directive / The shebang interpreter directive
    • executing / Ensuring Elasticsearch is running
    • test API server, executing in background / Running the test API server in the background
    • API server, checking /  Checking our API server is ready
    • API status, checking with netstat/ss / Checking API status using netstat/ss
    • background process, cleaning up / Cleaning up the background process
    • tests, executing / Running our tests
  • Elasticsearch Cluster
    • configuring / Configuring Elasticsearch cluster
    • networking, for Distributed Databases / Networking for distributed databases
    • Zen Discovery, configuring / Configuring Elasticsearch's Zen discovery
  • Elasticsearch images
    • elasticsearch (basic) / Running Elasticsearch on Docker 
    • elasticsearch-platinum / Running Elasticsearch on Docker 
    • elasticsearch-oss / Running Elasticsearch on Docker 
  • Elasticsearch Service
    • running / Running the Elasticsearch service
    • Zen Discovery, validating on remote cluster / Validating Zen Discovery on the remote cluster
  • Elliptic Curve Digital Signature Algorithm (ECDSA) / Creating an SSH key
  • Ember / Vanilla JavaScript vs. frameworks
  • End-to-End (E2E) tests
    • setting up, with Cucumber / Setting Up E2E tests with Cucumber
    • scenarios / Features, scenarios, and steps
    • scenario, testing / Testing the success scenario
    • updating / Updating existing E2E tests
    • random digest, generating / Generating a random digest
    • digest, validating / Validating a digest
    • writing, in Gherkin / Writing E2E tests with Gherkin, Cucumber, and Selenium
    • test script, adding / Adding test script
    • feature, specifying / Specifying a feature
    • IDs, adding to elements / Adding IDs to elements
    • Selenium, using / Selenium
    • WebDriver API, using / WebDriver API
    • Selenium WebDriver, using / Using Selenium WebDriver
    • headless browser, using / Headless browsers
    • browser drivers, using / Browser drivers
    • ChromeDriver, using / Setup and teardown
    • step definitions, implementing / Implementing step definitions
    • executing / Running the tests
    • multiple testing browsers, adding / Adding multiple testing browsers
    • backend API, running / Running our backend API
  • end-to-end encryption (E2EE) / Preventing man-in-the-middle (MITM) attacks
  • engine
    • creating / Creating engines
    • unit testing / Unit testing our engine
    • integration testing / Integration testing our engine
  • environment variables
    • reference / Setting up the environment
  • ES6
    • transpiling, with Babel / Transpiling ES6 with Babel
  • ES6 modules / The dawn of modules
  • ESLint
    • linting / Linting with ESLint
    • installing / Installing ESLint
    • code, linting / Linting our code
    • lint script, adding to package.json / Adding lint script to package.json
    • extension, installing / Installing the ESLint extension
    • pre-commit hooks, adding / Adding pre-commit hooks
    • arrow functions, in Mocha / Understanding arrow functions in Mocha
    • environments, specifying / Specifying ESLint environments
  • example claim / Example claim
  • exploratory testing / Exploratory testing
  • Express
    • API, migrating / Migrating our API to Express
    • routes, redefining / (Re)defining routes
    • body-parser middleware, using / Using body-parser middleware
  • expressiveness / Picking an object schema and validation library
  • extreme programming (XP) / You ain't gonna need it (YAGNI)

F

  • factors, for selecting library/ framework
    • popularity / Popularity/community
    • community / Popularity/community
    • features / Features
    • flexibility / Flexibility
    • performance / Performance
    • cross-platform / Cross-platform
    • learning curve / Learning curve
    • conclusion / Conclusion
  • failover / Load balancing versus failover
  • feature branches
    • creating / Creating feature branches
    • sub-branches, naming / Naming sub-branches
  • field-programmable gate arrays (FPGA) / Hash stretching algorithms
  • first-class citizens / Modularizing our request handlers
  • first-mover advantage (FMA) / What is technical debt?, The triple constraint
  • form submission, React
    • about / Submitting forms
    • uncontrolled form elements / Uncontrolled form elements
    • controlled form elements / Controlled form elements
  • freestyle project
    • about / Freestyle projects
    • configuring / Freestyle projects
  • front-end framework
    • selecting / Picking a front-end framework/library
  • full-text search engine / Introduction to Elasticsearch
  • fully qualified domain names (FQDNs) / Understanding DNS

G

  • GET endpoint
    • specifying / Specifying the GET /salt endpoint
  • Gherkin keyword / Gherkin keywords
  • Git
    • setting up / Setting up Git
    • repository, creating / Creating a new repository
    • configuring / Configuring Git
    • user, configuring / Configuring a user
    • learning / Learning the basics
    • committing, to history / Committing to history
    • file states / Understanding file states in Git
    • three tracked states / The three tracked states
    • staging area / Staging our changes
    • code, committing / Committing our code into Git
    • .gitignore, used for ignoring files / Using .gitignore to ignore files
  • Git branches / Git branches
  • GitHub plugin
    • reference / Using the GitHub plugin
  • Git plugin
    • reference / Using the GitHub plugin
  • Go
    • URL / Interoperability
  • granular / Structuring our test suite with the testing pyramid
  • GraphQL / What it means to be RESTful
  • greenfield projects /
  • grouping tokens / Naming sub-branches
  • GRPC / What it means to be RESTful

H

  • Hardware Security Module (HSM) / Implementation
  • hashing function / Hashing passwords
  • hash stretching / Picking a cryptographic hashing algorithm
  • header, JSON web token (JWT) / Header
  • headless browsers
    • about / Headless browsers
    • PhantomJS / Headless browsers
    • SlimerJS / Headless browsers
    • ZombieJS / Headless browsers
    • HtmlUnit / Headless browsers
  • Headless Service / Working with services
  • Helix TCM
    • URL / Writing manual tests
  • high availability
    • about / High availability
    • measuring / Measuring availability
    • industry standard, following / Following the industry standard
    • single points of failure (SPOF), eliminating / Eliminating single points of failure (SPOF)
    • load balancing, versus failover / Load balancing versus failover
    • load balancing / Load balancing
  • High Availability Proxy (HAProxy) / Layer 7 load balancing
  • higher-level Objects, Kubernetes
    • about / High-level objects, Understanding high-level Kubernetes objects
    • ReplicaSet / High-level objects
    • Deployment / High-level objects
    • StatefulSet / High-level objects
    • DaemonSet / High-level objects
    • Job / High-level objects
  • higher-order function / Modularizing our request handlers
  • high reliability
    • about / High reliability
    • testing for / Testing for reliability
  • high scalability / High scalability
  • high throughput / High throughput
  • Hiptest
    • URL / Writing manual tests
  • hook function / Asserting function calls with spies
  • hotfix / Hotfixes
  • HtmlUnit
    • about / Headless browsers
    • URL / Headless browsers
  • HTTP/2 / Isomorphic JavaScript applications, HTTP/2
  • HTTP cookies
    • about / HTTP cookies
    • Cross-Site Scripting (XSS) / Cross-Site Scripting (XSS)
    • Cross-Site Request Forgery (CSRF) attack / Cross-Site Request Forgery (XSRF)
  • HTTP headers
    • about / HTTP headers
    • Authorization header / The Authorization header
  • HTTP server
    • creating / Creating an HTTP server
    • detailing / Our HTTP server in detail
  • Husky / Adding pre-commit hooks
  • hybrid applications, with Ionic / Hybrid applications with Ionic
  • hype-driven development / Popularity/community
  • Hyper Text Transfer Protocol Secure (HTTPS) / Preventing man-in-the-middle (MITM) attacks
  • Hypervisor
    • installing / Installing a Hypervisor or Docker Machine

I

  • index / The three tracked states
  • Inferno / Vanilla JavaScript vs. frameworks
  • Ingress resource
    • deploying / Deploying the Ingress resource
  • initialization vectors / Hashing passwords
  • integration tests / Understanding different types of test
  • interface / What is REST?
  • interface constraints / What is REST?
  • intermediate language (IL) / What is Node.js?
  • International Organization for Standardization (ISO) / Using ISO formats
  • Internet Assigned Numbers Authority (IANA)
    • URL / Sending the correct HTTP status code
    • about / Registered claim names, The Authorization header
    • reference / The Authorization header
  • Internet Service Provider (ISP) / Obtaining an IP address, Understanding DNS
  • interoperability / Picking an object schema and validation library, Interoperability
  • interpreter / Just-in-time (JIT) compilers
  • interrupt signal (SIGINT) / Creating an HTTP server
  • intuitive design, API
    • about / Intuitive
    • URLs, for humans / URLs for humans
    • verbosity / Favor verbosity and explicitness
    • explicitness / Favor verbosity and explicitness
  • IP address
    • obtaining / Obtaining an IP address
    • Managed DNS / Managed DNS
  • Isomorphic JavaScript applications / Isomorphic JavaScript applications

J

  • Jasmine
    • URL / Picking a testing framework
  • Java
    • installing / Installing Java and Elasticsearch, Installing Java
    • URL / Interoperability
  • Java Development Kit (JDK) / Installing Java, Running our API
  • Java Runtime Environment (JRE) / Installing Java
  • JavaScript Object Notation (JSON) / Elasticsearch is a JSON document store, Consistent data exchange format
  • Javascript Object Signing and Encryption (JOSE) header
    • about / Header
    • reference / Header
  • Jenkins
    • about / Picking a CI server, Introduction to Jenkins
    • Continuous Integration (CI) / Continuous Integration with Jenkins
    • freestyle project, configuring / Freestyle projects
    • Pipeline / Pipeline
    • pipeline / Pipeline
    • installing / Installing Jenkins
    • configuring / Configuring Jenkins
    • integration, with GitHub / Integration with GitHub
  • Jenkins, with GitHub
    • about / Integration with GitHub
    • repository, accessing / Providing access to the repository
    • Personal Access (OAuth) Token / The Personal Access (OAuth) Token
    • GitHub plugin, using / Using the GitHub plugin
    • GitHub service hooks, setting up manually / Setting up GitHub service hooks manually
    • folder, creating / Creating a new folder
    • pipeline, creating / Creating a new pipeline
    • build, executing / Running the first build
  • Jenkinsfile
    • composing / Composing a Jenkinsfile
    • Pipeline DSL syntax / The Pipeline DSL syntax
    • declarative, versus scripted pipelines / Declarative versus scripted pipelines
    • declarative pipeline / The declarative pipeline
    • scripted pipeline / The scripted pipeline
    • environment, setting up / Setting up the environment
    • Docker, installing / Installing Docker
  • Jenkins server
    • setting up / Setting up a new Jenkins server
    • jenkins user, creating / Creating the jenkins user
    • time, configuring / Configuring time
    • Java, installing / Installing Java
    • NGINX, installing as reverse proxy / Installing NGINX as a reverse proxy
    • firewall, configuring / Configuring the firewall
    • DNS records, updating / Updating our DNS records
  • Jest
    • URL / Picking a testing framework
  • Jetty server
    • reference / Installing Jenkins
  • jobs / Freestyle projects
  • joi
    • URL / Types of schema
  • jQuery / Choosing a framework/library
  • JSON Schema
    • URL / Types of schema
  • JSON Web Algorithms (JWA) / Signature, Terminology and summary
  • JSON Web Encryption (JWE) / Header, Terminology and summary
  • JSON Web Key (JWK) / Terminology and summary
  • JSON Web Signature (JWS) / Header, Terminology and summary
  • JSON web token (JWT)
    • about / What is REST?, JSON web tokens (JWTs)
    • header / Anatomy of a JWT, Header
    • anatomy / Anatomy of a JWT
    • payload / Anatomy of a JWT, Payload and claims
    • signature / Anatomy of a JWT, Signature
    • claims / Payload and claims
    • encryption / A note on encryption
    • summary / Terminology and summary
    • terminology / Terminology and summary
  • JSON web token (JWT), attaching
    • about / Attaching the token
    • with HTTP cookies / HTTP cookies
    • with HTTP headers / HTTP headers
    • tests, writing / Writing tests
    • digest, verifying in request / Verifying the digest in the request
  • JSON web token (JWT), implementing
    • E2E Tests, adding / Adding E2E Tests
    • about / Implementation
    • multiline environment variables / Multiline environment variables
    • token, generating / Generating the token
  • jspm / jspm
  • JSX
    • about / JSX
    • transpiling / Transpiling JSX
  • Just-in-time (JIT) compilers / Just-in-time (JIT) compilers
  • JWS signature / Signature

K

  • Kanban / Defining processes
  • kangax ECMAScript compatibility tables
    • URL / The env preset
  • karma / Learning curve
  • Keep It Simple Stupid (KISS) / Keep It Simple Stupid (KISS)
  • key-value (KV) / Master components
  • Knockout / Choosing a framework/library
  • kube-apiserver / kube-apiserver
  • kube-control-manager / kube-control-manager
  • kube-proxy / kube-proxy
  • kubectl
    • installing / Installing kubectl
  • kubelet / kubelet
  • Kubernetes
    • about / Picking a cluster management tool
    • components / Control Planes and components
    • Master Components / Master components
    • Node Components / Node components
    • imperative approach / Declarative over imperative
    • declarative approach / Declarative over imperative
  • Kubernetes Objects
    • about / Kubernetes objects
    • basic Objects / The four basic objects
    • Pod / The four basic objects
    • Service / The four basic objects
    • volume / The four basic objects
    • namespace / The four basic objects
    • higher-level Objects / High-level objects
    • Controllers / Controllers
    • management hierarchy / Kubernetes Object management hierarchy
    • visualizing, Web UI dashboard used / Visualizing Kubernetes Objects using the Web UI Dashboard
  • Kubernetes Volumes
    • defining / Defining Volumes
    • manually-managed Volumes, problems / Problems with manually-managed Volumes

L

  • L7 load balancer
    • advantages / Layer 7 load balancing
  • labels / A note on labels
  • layer 4 / 7 load balancers
    • about / Layer 4/7 load balancers
    • layer 4 load balancers / Layer 4 load balancers
    • layer 7 load balancing / Layer 7 load balancing
  • Let's Encrypt
    • reference / Preventing man-in-the-middle (MITM) attacks
  • load-balanced servers / What is REST?
  • load balancing
    • about / Load balancing versus failover, Load balancing
    • DNS load balancing / DNS load balancing
    • layer 4 / 7 load balancers / Layer 4/7 load balancers
  • Loader specification / SystemJS and the Loader specification
  • local development environment
    • setting up / Setting up the local development environment
    • hardware requisites, checking / Checking hardware requirements
    • environment, cleaning / Cleaning our environment
    • Swap Memory, disabling / Disabling swap memory
    • kubectl, installing / Installing kubectl
    • Minikube, installing / Installing Minikube
    • Hypervisor, installing / Installing a Hypervisor or Docker Machine
    • Docker Machine, installing / Installing a Hypervisor or Docker Machine
  • lock file / Package version locking
  • Login endpoint, password-base authentication
    • tests, writing / Writing tests
    • implementing / Implementing Login
  • Long Term Support (LTS) / Choosing an image
  • lookup tables / Preventing brute-force attacks against a single user

M

  • machine code / Just-in-time (JIT) compilers
  • man-in-the-middle (MITM) attacks
    • about / Introduction to password-based authentication
    • preventing / Preventing man-in-the-middle (MITM) attacks
  • Managed DNS services / Managed DNS
  • manual deployment
    • issues / Problems with manual deployment
  • manual tests / Understanding different types of test
  • Marathon
    • URL / Picking a cluster management tool
  • Master Components
    • about / Master components
    • etcd / Master components
    • kube-scheduler / Master components
    • kube-apiserver / kube-apiserver
    • kube-control-manager / kube-control-manager
  • merge conflict / Merging branches
  • message / Hashing passwords
  • Message Authentication Code (MAC) / Anatomy of a JWT, Symmetric signature generation
  • Meteor / Vanilla JavaScript vs. frameworks
  • microservices / Microservices
  • middleware
    • checks, performing / Moving common logic into middleware
    • modularizing / Modularizing our middleware
    • unit testing / Unit testing middleware
    • equality, asserting / Asserting deep equality
    • function calls, asserting with spies / Asserting function calls with spies
    • behavior, simulating with stubs / Simulating behavior with stubs
    • functions, testing / Testing all middleware functions
  • Minikube
    • installing / Installing Minikube
  • Minimum Viable Product (MVP) / Technical debt
  • Mithril / Choosing a framework/library
  • MobX
    • about / MobX
    • versus Redux / Redux versus MobX
  • Mocha
    • URL / Picking a testing framework
    • installing / Installing Mocha
    • arrow functions / Understanding arrow functions in Mocha
    • about / Promises and Mocha
    • rejected promises, dealing with / Dealing with rejected promises
    • unit tests, completing / Completing the unit tests
  • module bundlers
    • Browserify / Browserify
    • Webpack / Webpack
    • Rollup / Rollup
    • Parcel / Parcel
    • versus, module loader / Module bundler versus module loader
  • module loaders / AMD and Require.js
  • modules / The dawn of modules
  • module wrapper / Fulfilling the encapsulation requirement
  • monkey patching / Stubbing create, Monkey patching
  • multi-page applications (MPAs) / Picking a front-end framework/library
  • multi-stage builds / Multi-stage builds

N

  • Namecheap Dashboard
    • URL / Updating the domain nameserver
  • NativeScript / Native UI with React Native and Weex
  • Native UI, with React Native and Weex / Native UI with React Native and Weex
  • ndb
    • URL / Using ndb
  • Networking tab
    • URL / Building our zone file
  • NGINX
    • setting up / Setting up NGINX
    • configuring / Configuring NGINX
    • configuration file / Understanding NGINX's configuration file
    • HTTP module, configuring / Configuring the HTTP module
    • nginx.conf, splitting into multiple files / Splitting nginx.conf into multiple files
    • updating / Updating NGINX
    • installing, as reverse proxy / Installing NGINX as a reverse proxy
  • NGINX Ingress Controller
    • deploying / Deploying the NGINX Ingress Controller
    • URL / Deploying the NGINX Ingress Controller
  • No-IP
    • URL / Managed DNS
  • Node
    • installing / Installing Node
    • installing, with nvm / Using nvm to install Node
    • versions, documenting / Documenting Node versions
  • node-level tools
    • about / Cluster management
    • local configuration management tools / Cluster management
    • container runtime / Cluster management
  • Node.js
    • benefits / Benefits of Node.js
    • context switching / Context switching
    • shared code / Shared code
    • about / What is Node.js?
    • terminology / Terminology
  • Node Components
    • container runtime / Container runtime
    • kubelet / kubelet
    • kube-proxy / kube-proxy
  • Node configuration, for Elasticsearch
    • about / Configuring nodes for Elasticsearch
    • commands, running on multiple servers / Running commands on multiple servers
  • Node Docker images
    • standard / Using a lighter image
    • slim / Using a lighter image
    • stretch / Using a lighter image
    • alpine / Using a lighter image
  • Node modules
    • about / Modules, The dawn of modules
    • evolution / The birth of Node.js modules
    • CommonJS standard, adoption / Adoption of the CommonJS standard
    • encapsulation requisites, fulfilling / Fulfilling the encapsulation requirement
    • formats, standardizing / Standardizing module formats
  • nodemon
    • used, for automating development / Automating development using nodemon
  • Node Version Manager (nvm) / Installing Node
  • non-permanent branches
    • feature branches / The Driessen model
    • release branches / The Driessen model
    • hotfix branches / The Driessen model
  • nonce (one-time token) / Registered claim names
  • normalized data / Elasticsearch versus other distributed document store
  • npm
    • projects, initiating / Starting projects with npm
    • URL / Using yarn instead of npm
  • npm packages / Shared code
  • npm scripts
    • about / Avoiding manual tests
    • commands, consolidating / Consolidating commands with npm scripts
    • cross-platform compatibility / Ensuring cross-platform compatibility

O

  • object-oriented (OO) language / Switching between languages
  • OpenAPI
    • overview / Overview of OpenAPI and Swagger
    • API specification language, selecting / Picking an API specification language
    • versus Swagger / Swagger vs OpenAPI
    • API specification, defining / Defining an API specification with OpenAPI
    • YAML / Learning YAML
    • root fields, overview / An overview of the root fields
    • GET /salt endpoint, specifying / Specifying the GET /salt endpoint
    • Create User endpoint, specifying / Specifying the Create User endpoint
    • request body, specifying / Specifying the request body
    • common components, defining / Defining common components
    • Retrieve User endpoint, specifying / Specifying the Retrieve User endpoint
    • Replace Profile endpoint, specifying / Specifying the Replace Profile endpoint
    • rest, specifying of endpoints / Specifying the rest of the endpoints
  • Open Container Initiative (OCI)
    • URL / LXC and Docker, Container runtime
    • Image Specification / LXC and Docker
    • Runtime Specification / LXC and Docker
  • Open Systems Interconnection (OSI) reference model / Layer 4/7 load balancers
  • optimistic locking / Understanding indices, types, documents, and versions
  • ordinal index / Ordinal index
  • ordinal number / Ordinal index

P

  • parameters / Combining duplicate step definitions
  • Parcel / Parcel
  • passphrase / Protecting against brute-force attacks
  • password-based authentication
    • about / Introduction to password-based authentication
    • passwords, hashing / Hashing passwords
    • brute-force attacks, preventing / Preventing brute-force attacks against a single user
    • reverse lookup table attacks / Reverse lookup table attacks
    • implementing / Implementing password-base authentication
    • existing E2E tests, updating / Updating existing E2E tests
    • existing implementation, updating / Updating an existing implementation
    • salt, retrieving / Retrieving the salt
    • salt, generating for non-existent users / Generating a salt for non-existent users
    • Login endpoint, implementing / Login
  • Password-Based Key Derivation Function 2 (PBKDF2) / Hash stretching algorithms
  • passwords, hashing
    • about / Hashing passwords
    • cryptographic hash functions / Cryptographic hash functions
    • cryptographic hashing algorithm, selecting / Picking a cryptographic hashing algorithm
  • payload
    • validating / Validating our payload
    • required fields, checking / Checking for required fields
    • property type, checking / Checking property type
    • property's format, checking / Checking the payload property's format
    • step definitions, refactoring / Refactoring our step definitions
  • pepper / Encrypting digests
  • perennial consistency / Consistent, Perennial consistency
  • PersistentVolume (PV)
    • about / Introducing PersistentVolume (PV)
    • consuming, with PVC / Consuming PVs with PersistentVolumeClaim (PVC)
    • PVC, deleting / Deleting a PersistentVolumeClaim
    • deleting / Deleting a PersistentVolume
    • manually provisioning PersistentVolume, issues / Problems with manually provisioning PersistentVolume
    • provisioning, to StatefulSet / Provisioning PersistentVolume to StatefulSet
    • permissions, configuring on bind-mounted directory / Configuring permissions on a bind-mounted directory
  • PersistentVolumeClaim (PVC) / Consuming PVs with PersistentVolumeClaim (PVC)
  • Personal Access (OAuth) Token / The Personal Access (OAuth) Token
  • PhantomJS
    • about / Headless browsers
    • URL / Headless browsers
  • Pipeline
    • steps / Pipeline
    • stages / Pipeline
  • pipeline stage view plugin
    • reference / Running the first build
  • plugins / Plugins and presets
  • PM2
    • API, executing / Keeping our API alive with PM2
    • process, killing / Killing a process
    • executing / Keeping PM2 alive
  • Pod
    • creating / Creating our first Pod
    • running, with kubelet / Running Pods with kubelet
    • running, with kubectl run / Running Pods with kubectl run
    • running, declaratively with kubectl apply / Running pods declaratively with kubectl apply
  • Polymer / Choosing a framework/library
  • port 80
    • API, executing / Running our API on port 80
    • privileged ports / Privileged ports
    • solutions / Possible solutions
    • root, executing / Running as root
    • privileges, de-escalating / De-escalating privileges
    • capabilities, setting up / Setting capabilities
    • authbind, using / Using authbind
    • iptables, using / Using iptables
    • reverse proxy, using / Using reverse proxy
    • reverse proxy / What's a proxy? What's a reverse proxy?
  • port redirect / Managed DNS
  • Post-React / Post-React
  • Preact / Choosing a framework/library
  • presets / Plugins and presets
  • Principle of Least Astonishment (POLA) / Intuitive
  • private claim names / Private claim names
  • privileged port / Privileged ports
  • Process ID (PID) / Cleaning up the background process
  • profile schema
    • creating / Creating our profile schema
    • additional properties, rejecting / Rejecting additional properties
    • dynamic mapping, in Elasticsearch / Dynamic mapping in Elasticsearch
    • specificity, adding to sub-schema / Adding specificity to a sub-schema
    • title, adding / Adding a title and description
    • description, adding / Adding a title and description
    • meta-schema, specifying / Specifying a meta-schema
    • unique ID, specifying / Specifying a unique ID
  • projects / Freestyle projects
  • promises
    • about / Promises and Mocha
  • Proof of Concept (PoC) / When not to use TDD
  • Protractor / Learning curve
  • proxy / What's a proxy? What's a reverse proxy?
  • pseudorandom number generator (PRNG) / Generating a salt for non-existent users
  • public claim names / Public claim names
  • pull request (PR) / Conducting peer review through pull requests
  • Puppeteer
    • URL / Using ndb
  • Python
    • URL / Interoperability

Q

  • qTest
    • URL / Writing manual tests

R

  • rainbow tables / Preventing brute-force attacks against a single user
  • random digest, E2E tests
    • generating / Generating a random digest
    • bcrypt library, selecting / Picking a bcrypt library
    • bcryptjs library, using / Using the bcryptjs library
  • RCP / What it means to be RESTful
  • React
    • about / Vanilla JavaScript vs. frameworks, Getting started with React, What is React?
    • components / Components
    • Virtual DOM / Virtual DOM
    • declarative / React is declarative
    • summarizing / React summary
    • repository, starting / Starting a new repository
    • boilerplate, adding / Adding some boilerplate
    • first component, creating / Creating our first component
    • JSX / JSX
    • components, defining / Defining React components
    • state, maintaining / Maintaining the state and listening for events, setState and immutability
    • events, listening for / Maintaining the state and listening for events
    • event handling / Handling events
    • state, rendering / Rendering the state
    • forms, submitting / Submitting forms
  • React, modularizing
    • about / Modularizing React
    • client-side modules / Client-side modules
  • React Native / Native UI with React Native and Weex
  • React Redux
    • connecting with / Connecting with React Redux
  • React Router
    • components / Basics
    • router component / Router
    • route matching / Route matching
    • history API, supporting / Supporting the History API
    • navigation / Navigation
  • Redundant Array Of Inexpensive Servers (RAIS) / Clusters
  • Redux
    • about / Redux
    • versus MobX / Redux versus MobX
    • installing / Converting to Redux
    • converting to / Converting to Redux
    • store, creating / Creating the store
    • state, lifting / Lifting the state up
    • actions, dispatching / Dispatching actions
    • state, updating with Reducer / Updating the state with the Reducer
    • Provider component / Wrapping with the Provider component
    • decoupling, from components / Decoupling Redux from components
  • Redux DevTools
    • reference / Converting to Redux
  • Redux store
    • connecting to / Connecting to the Redux store
    • mapStateToProps function / mapStateToProps
    • mapDispatchToProps function / mapDispatchToProps
  • ref / Uncontrolled form elements
  • refactoring
    • about / What is technical debt?, Refactoring
    • contexts, isolating for each scenario / Isolating contexts for each scenario
    • failure information / Making failure more informative
    • hardcoded values, removing / Removing hardcoded values
  • registered claim names / Registered claim names
  • regressions / Test-Driven Development
  • relational databases / Elasticsearch is a JSON document store
  • release branch
    • creating / Creating a release branch
  • releases
    • tagging / Tagging releases
  • reliability
    • about / High reliability
    • mean time between failures (MTBF) / High reliability
    • mean time to repair (MTTR) / High reliability
  • remote repository
    • working with / Working with others
    • creating / Creating a remote repository
    • pulling / Pulling and pushing
    • pushing / Pulling and pushing
    • cloning / Cloning a repository
    • peer review, conducting through pull requests / Conducting peer review through pull requests
  • Replace Profile endpoint
    • specifying / Specifying the Replace Profile endpoint
  • repository / Creating a new repository
  • representational state transfer (REST) / What is REST?
  • request
    • URL / Implementing step definitions
  • request handler
    • unit testing / Unit testing the request handler
    • stubs, creating / Stubbing create
    • dependency injection / Dependency injection
    • monkey patching / Monkey patching
    • dependency injection, versus monkey patching / Dependency injection versus monkey patching
    • dependency injection pattern, following / Following the dependency injection pattern
    • Promises / Promises and Mocha
    • Mocha / Promises and Mocha
  • request handler function / Our HTTP server in detail
  • request handlers
    • modularizing / Modularizing our request handlers
  • Require.js / AMD and Require.js
  • RequireJS / The dawn of modules
  • resource / What is REST?
  • REST / What it means to be RESTful, What REST is not
  • REST, requisites
    • client-server / What is REST?
    • stateless / What is REST?
    • cacheable / What is REST?
    • layered system / What is REST?
    • code on demand / What is REST?
    • uniform interface / What is REST?
  • RESTful
    • about / What it means to be RESTful
    • REST / What is REST?
  • Retrieve User endpoint
    • specifying / Specifying the Retrieve User endpoint
  • retrospective / Defining processes
  • reverse lookup table attacks
    • about / Reverse lookup table attacks
    • protecting against / Protecting against reverse lookup table attacks
  • reverse proxied / What is REST?
  • reverse proxy
    • using / Using reverse proxy
    • about / What's a proxy? What's a reverse proxy?
  • rewire
    • URL / Monkey patching
  • RFC7519
    • reference / Keeping users authenticated
  • rimraf
    • URL / Ensuring cross-platform compatibility
  • Riot / Vanilla JavaScript vs. frameworks
  • Rivest-Shamir-Adleman (RSA) / Creating an SSH key
  • Rollup / The dawn of modules, Rollup
  • root fields
    • overview / An overview of the root fields
  • routing, with React Router
    • about / Routing with React Router
    • basics / Basics
  • rows / Elasticsearch is a JSON document store
  • RxJS / Learning curve

S

  • /salt endpoint
    • specifying / Specifying the GET /salt endpoint
    • parameters, specifying / Specifying parameters
    • responses, specifying / Specifying responses
  • salt
    • about / Protecting against reverse lookup table attacks
    • retrieving / Retrieving the salt
    • Retrieve Salt endpoint, implementing / Implementing the Retrieve Salt endpoint
    • Retrieve Salt engine, implementing / Implementing a Retrieve Salt engine
    • generating, for non-existent users / Generating a salt for non-existent users
    • E2E tests, writing / Writing E2E tests
    • implementation / Implementation
  • same-origin policy / Same-origin policy
  • scalability
    • about / High scalability
  • schema / Schema-based validation
  • scope hoisting / Rollup
  • scripted pipeline
    • versus declarative pipeline / Declarative versus scripted pipelines
    • about / The scripted pipeline
  • scrypt / Hash stretching algorithms
  • Search Engine Optimization (SEO) / Isomorphic JavaScript applications
  • Secure Remote Password (SRP) protocol
    • exploring / Exploring the Secure Remote Password (SRP) protocol
    • reference / Exploring the Secure Remote Password (SRP) protocol
  • security, Docker image / Security
  • Selenium
    • URL / Understanding different types of test
  • Selenium Remote Control (RC) / Selenium
  • Selenium WebDriver
    • using / Using Selenium WebDriver
  • semantic versioning / Releasing code
  • Semantic versioning / Semantic versioning
  • semver / Releasing code
  • separation of concerns (SoC) / Modules, What is REST?
  • server-side rendering (SSR) / Isomorphic JavaScript applications, Choosing a framework
  • service level agreement (SLA) / Following the industry standard
  • Services, through Ingress
    • exposing / Exposing services through Ingress
    • NGINX Ingress Controller, deploying / Deploying the NGINX Ingress Controller
    • Ingress resource, deploying / Deploying the Ingress resource
    • DNS records, updating / Updating DNS records
  • setState method
    • using / setState and immutability
  • shared code / Benefits of Node.js, Shared code
  • shebang interpreter directive / The shebang interpreter directive
  • side-effects / Understanding different types of test
  • signature, JSON web token (JWT)
    • about / Signature
    • asymmetric signature, generating / Asymmetric signature generation
    • symmetric signature, generating / Symmetric signature generation
    • algorithm, selecting / Picking an algorithm
  • single page applications (SPAs) / Single page applications (SPAs), The dawn of modules, Picking a front-end framework/library
  • single responsibility principle / The single responsibility principle
  • SlimerJS
    • URL / Headless browsers
    • about / Headless browsers
  • SOAP / What it means to be RESTful
  • SOLID principle
    • single responsibility / The single responsibility principle
    • open/closed / The single responsibility principle
    • Liskov substitution / The single responsibility principle
    • interface segregation / The single responsibility principle
    • dependency inversion / The single responsibility principle
  • Specification-as-Code (SaC) / Writing tests as specification
  • spies
    • function calls, asserting / Asserting function calls with spies
  • sprints / Defining processes
  • staging area / The three tracked states
  • Start of Authority (SOA) / Start of Authority (SOA)
  • state management tools
    • about / State management tools
    • Redux / Redux
    • MobX / MobX
  • static / Standardizing module formats
  • step definition implementation, E2E tests
    • page, navigating to / Navigating to a page
    • input, typing into / Typing into input
    • result, asserting / Asserting a result
  • step definitions
    • about / Laying out our step definitions
    • implementing / Implementing step definitions
    • endpoint, calling / Calling our endpoint
    • results, asserting / Asserting results
    • debugger, used for Node.js debugging / Using a debugger for Node.js debugging
    • Chrome DevTools, using / Using Chrome DevTools
    • ndb, using / Using ndb
    • Visual Studio Code debugger, using / Using the Visual Studio Code debugger
    • line numbers, retaining / Retaining line numbers
    • req object, examining / Examining the req object
    • work-in-progress (WIP) commits, creating / Making work-in-progress (WIP) commits
    • correct response status code, asserting / Asserting the correct response status code
    • You ain't gonna need it (YAGNI) / You ain't gonna need it (YAGNI)
    • correct response payload, asserting / Asserting the correct response payload
    • correct response payload content, asserting / Asserting the correct response payload content
    • refactoring / Refactoring
  • StorageClass
    • defining / Defining a StorageClass
    • csi-digitalocean provisioner, using / Using the csi-digitalocean provisioner
  • stubs
    • behavior, simulating / Simulating behavior with stubs
  • sub-schema / Creating our profile schema
  • sub-token / Naming sub-branches
  • superagent
    • URL / Implementing step definitions
  • Svelte / Choosing a framework/library
  • Swagger
    • overview / Overview of OpenAPI and Swagger
    • versus OpenAPI / Swagger vs OpenAPI
    • Swagger Toolchain / Swagger Toolchain
    • Swagger Editor / Swagger Editor
    • Swagger UI / Swagger UI
    • Swagger Inspector / Swagger Inspector
    • Swagger codegen / Swagger codegen
  • Swagger UI
    • documentation, generating / Generating documentation with Swagger UI
    • adding, to repository / Adding the Swagger UI to our repository
    • specification, using / Using our specification in the Swagger UI
    • swagger.yaml, exposing from API / Exposing swagger.yaml from our API
    • CORS, enabling / Enabling CORS
    • implementing / Final touches
    • specification URL, replacing / Replacing the specification URL
    • header, removing / Removing the header
  • Swap Memory
    • disabling / Disabling swap memory
  • Swarm
    • URL / Picking a cluster management tool
  • Swift
    • URL / Interoperability
  • symbolic link / Splitting nginx.conf into multiple files
  • symmetric-key encryption / Block cipher
  • SystemJS / The dawn of modules, Learning curve, SystemJS and the Loader specification

T

  • tables / Elasticsearch is a JSON document store
  • tags
    • about / Tagging releases
    • lightweight tags / Tagging releases
    • annotated tags / Tagging releases
  • task runners
    • Grunt / Webpack
    • Gulp / Webpack
  • TCP/IP protocol / Obtaining an IP address
  • TDD workflow
    • business requirements, obtaining / Gathering business requirements
    • requisites, formalizing through documentation / Formalizing requirements through documentation
    • requisites, refining into specification / Refining requirements into specification
    • tests, writing as specification / Writing tests as specification
    • process / Test-driven development
    • manual tests, writing / Writing manual tests
    • exploratory testing / Exploratory testing
    • maintenance / Maintenance
  • TeamCity / Picking a CI server
  • technical debt
    • about / Technical debt, What is technical debt?
    • causes / Causes of technical debt
    • debt spiral / The debt spiral
    • consequences / Consequences of technical debt
    • morale, lowering /
    • low morale, consequences / Consequences of low morale
    • repaying, through refactoring / Repaying technical debt through refactoring
    • preventing / Preventing technical debt
    • decision makers, informing / Informing the decision makers
    • triple constraint / The triple constraint
    • triple constraint fallacy / The fallacy of the triple constraint
    • development, refusing / Refuse to develop
    • processes, defining / Defining processes
  • technical specifications / Refining requirements into specification
  • Test-Driven Development (TDD)
    • about / Test-Driven Development, TDD
    • process / Understanding the TDD process
    • bugs, fixing / Fixing bugs
    • benefits / Benefits of TDD
    • manual tests, avoiding / Avoiding manual tests
    • tests as specification / Tests as specification
    • tests as documentation / Tests as documentation
    • short development cycles / Short development cycles
    • disadvantages / Difficulties with TDD adoption
    • avoiding / When not to use TDD
    • workflow / Following a TDD workflow
    • login / Login
    • test, writing / Writing tests
    • tests, writing / Writing tests
    • Login, implementing / Implementing Login
  • test case management tools / Writing manual tests
  • test coverage
    • adding / Adding test coverage
    • report, reading / Reading a test coverage report
    • enhancing / Improving test coverage
    • code coverage, versus test quality / Code coverage versus test quality
    • avoiding / You don't have to test everything, all the time
    • unifying / Unifying test coverage
    • files, ignoring / Ignoring files
  • test files
    • structuring / Structuring our test files
  • testing framework
    • selecting / Picking a testing framework
    • pros / Picking a testing framework
    • cons / Picking a testing framework
    • Mocha, installing / Installing Mocha
  • Testing Pyramid / Avoiding manual tests, Structuring our test suite with the testing pyramid
  • testing strategies
    • about / Testing strategies
    • automated UI testing / Automated UI testing
    • unit testing / Unit testing
    • browser testing / Browser testing
  • TestLink
    • URL / Writing manual tests
  • TestRail
    • URL / Writing manual tests
  • tests
    • about / Understanding different types of test
    • unit tests / Understanding different types of test
    • integration tests / Understanding different types of test
    • E2E/functional tests / Understanding different types of test
    • user interface (UI) tests / Understanding different types of test
    • manual tests / Understanding different types of test
    • acceptance tests / Understanding different types of test
    • test suite, structuring with testing pyramid / Structuring our test suite with the testing pyramid
    • feature, implementing / When implementing a new feature, write your E2E tests first
    • E2E tests, writing / When implementing a new feature, write your E2E tests first
  • tests, JSON web token (JWT)
    • writing / Writing tests
    • scenarios / Features and scenarios
    • features / Features and scenarios
    • step definitions, implementing / Implementation step definitions
  • three-way handshake / HTTP/2
  • throughput
    • about / High throughput
    • strategies, for increasing / High throughput
  • tightly coupled / Decoupling our validation logic
  • time-to-first-render (TTFR) / Isomorphic JavaScript applications, The birth of Node.js modules
  • time-to-live (TTL) value / NS records
  • top-level domain (TLD) / Understanding DNS
  • Traceur / Standardizing module formats, Transpiling ES6 with Babel
  • tracked state
    • modified / The three tracked states
    • staged / The three tracked states
    • committed / The three tracked states
  • transport layer / Layer 4 load balancers
  • transversal consistency / Transversal consistency
  • Travis CI
    • integrating with / Integrating with Travis CI
    • permissions / Integrating with Travis CI
    • configuring / Configuring Travis CI
    • language, specifying / Specifying the language
    • databases, setting up / Setting up databases
    • environment variables, setting / Setting environment variables
    • reference / Activating our project
    • project, activating / Activating our project
    • results, examining / Examining Travis CI results
  • tree shaking / Isomorphic JavaScript applications, Rollup
  • triple constraint model / Informing the decision makers
  • Trusted Platform Module (TPM) / Implementation
  • Two-Factor Authentication (2FA) / Setting up a Virtual Private Server (VPS)
  • type mapping / Dynamic mapping in Elasticsearch
  • TypeScript / Learning curve
  • TypeScript compiler / Transpiling ES6 with Babel

U

  • uncontrolled form elements
    • about / Uncontrolled form elements
    • CORS issues, resolving / Resolving CORS issues
    • button component, disabling / Disabling the Button component
  • units / Understanding different types of test
  • unit test
    • about / Understanding different types of test
    • writing / Writing our first unit test
    • behavior, describing / Describing the expected behavior
    • ESLint, overriding for test files / Overriding ESLint for test files
    • executing / Running our unit tests
    • executing, as npm script / Running unit tests as an npm script
  • unit testing
    • engine / Unit testing our engine
    • about / Unit testing
    • logical units / Logical units
    • component units / Component units
  • unit test suite
    • completing / Completing our first unit test suite
  • Universal Module Definition / Universal Module Definition
  • Universal Time Coordinated (UTC) / Configuring the time zone
  • untracked state / Understanding file states in Git
  • user authentication
    • managing / Keeping users authenticated
    • JSON web token (JWT) / JSON web tokens (JWTs)
    • JSON web token (JWT), implementing / Responding with a token
    • JSON web token (JWT), attaching / Attaching the token
  • user experience (UX) / Understanding different types of test
  • user interface (UI) tests / Understanding different types of test
  • user profile
    • adding / Adding a user profile
    • specification, writing as test / Writing a specification as a test
    • schema-based validation / Schema-based validation
    • schema, types / Types of schema
    • object schema, selecting / Picking an object schema and validation library
    • validation library, selecting / Picking an object schema and validation library
    • interoperability / Interoperability
    • expressiveness / Expressiveness
    • profile schema, creating / Creating our profile schema
    • schema, creating for Create User request payload / Creating a schema for the Create User request payload
    • JSON Schema validation library, selecting / Picking a JSON Schema validation library
    • validating, against JSON Schema with Ajv / Validating against JSON Schema with Ajv
  • user schema
    • validation error messages, generating / Generating validation error messages
    • functions, generalizing / Generalizing functions
    • npm build script, updating / Updating the npm build script
    • success scenario, testing / Testing the success scenario
    • test index, resetting / Resetting our test index

V

  • validate.js
    • URL / Types of schema
  • ValidationError
    • unit testing / Unit testing ValidationError
  • validation logic
    • decoupling / Decoupling our validation logic
    • ValidationError interface, creating / Creating the ValidationError interface
    • modularizing / Modularizing our validation logic
  • vanilla JavaScript
    • versus, frameworks / Vanilla JavaScript vs. frameworks
  • Virtual DOM
    • about / Virtual DOM, Virtual DOM
    • JSX / JSX
    • used, for improving performance / How Virtual DOM improves performance
  • virtual machine (VM) / Managed DNS
  • Virtual Private Server (VPS)
    • setting up / Setting up a Virtual Private Server (VPS)
    • instance, creating / Creating a VPS instance
    • image, selecting / Choosing an image
    • size, selecting / Choosing a size
    • data center region, selecting / Picking a data center region
    • additional options, selecting / Selecting additional options
    • server, naming / Naming your server
    • connecting to / Connecting to the VPS
    • user accounts, setting up / Setting up user accounts
    • new user, creating / Creating a new user
    • user, adding to sudo group / Adding a user to the sudo group
    • public key authentication, setting up / Setting up public key authentication
    • existing SSH key(s), checking for / Checking for existing SSH key(s)
    • SSH key, creating / Creating an SSH key
    • SSH key, adding to remote server / Adding the SSH key to the remote server
    • ssh-copy-id, using / Using ssh-copy-id
    • security, providing / Providing extra security
    • password-based authentication, disabling / Disable password-based authentication
    • root login, disabling / Disable root login
    • firewall / Firewall
    • time zone, configuring / Configuring the time zone
  • Visual Studio Code debugger
    • using / Using the Visual Studio Code debugger
  • Vue.js / Vanilla JavaScript vs. frameworks

W

  • W3Techs
    • URL / HTTP/2
  • Waterfall / Defining processes
  • web application
    • evolution / Evolution of the web application
    • Just-in-time (JIT) compilers / Just-in-time (JIT) compilers
    • single page applications (SPAs) / Single page applications (SPAs)
    • Isomorphic JavaScript applications / Isomorphic JavaScript applications
  • Web Application ARchive (WAR) file
    • about / Installing Jenkins
    • reference / Installing Jenkins
  • WebAssembly / Isomorphic JavaScript applications
  • WebDriver API / WebDriver API
  • Webpack
    • about / Shared code, The dawn of modules, Webpack, Webpack
    • components, modularizing / Modularizing our components
    • entry/output / Entry/output
    • loaders / Loaders
    • plugins / Plugins
    • files, copying / Copying files
  • Web UI Dashboard
    • launching locally / Launching the Web UI Dashboard locally
    • launching, on remote cluster / Launching the Web UI Dashboard on a remote cluster
  • WebView container / Hybrid applications with Ionic
  • Weex / Native UI with React Native and Weex
  • work-in-progress (WIP) commits / Using merge and rebase together, Making work-in-progress (WIP) commits
  • working directory / Understanding file states in Git
  • working tree / Understanding file states in Git
  • world / Isolating contexts for each scenario
  • World Wide Web Consortium (W3C) / Common consistency, Cross-Origin Resource Sharing (CORS)

Y

  • YAML / Learning YAML
  • yarn
    • using / Using yarn instead of npm
    • URL / Using yarn instead of npm
    • package version, locking / Package version locking
    • offline cache / Offline cache
    • speed / Speed
    • installing / Installing yarn
    • yarn CLI / Getting familiar with the yarn CLI
    • using, with npm / npm and yarn, together
  • yarn CLI
    • URL / Getting familiar with the yarn CLI
  • You Aren't Gonna Need It (YAGNI) principle / Tests as specification

Z

  • Zen Discovery
    • configuring / Configuring Elasticsearch's Zen discovery
    • hostnames, attaching to Pods / Attaching hostnames to Pods
    • StatefulSets, working with / Working with StatefulSets
    • services, working with / Working with services
    • StatefulSet, linking to Service / Linking StatefulSet to a service
    • configuration, updating / Updating Zen Discovery configuration
    • validating / Validating Zen Discovery
  • ZombieJS
    • about / Headless browsers
    • URL / Headless browsers
  • zone file / Understanding DNS