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
- axios
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
- 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
- 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
- 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)
- digital signature / Anatomy of a JWT, Signature
- directives
- 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
- 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
- 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
- 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
- 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
- Managed DNS services / Managed DNS
- manual deployment
- issues / Problems with manual deployment
- manual tests / Understanding different types of test
- Marathon
- 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
- 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
- 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
- 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
- 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
- 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
- security, Docker image / Security
- Selenium
- 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
- 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
- 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
- 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
- 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
- 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
