Index
A
- A record (DNS), Nameservers
- abstracting of database layer, Abstracting the Database Layer-Abstracting the Database Layer
- Access-Control-Allow-Origin header, Cross-Origin Resource Sharing
- accrual value, Best Practices
- aesthetics (QA element), QA: Is It Worth It?
- Ajax
- Amazon
- analytics, maintenance and, Monitor Analytics
- Angular, SPA Technologies
- Apache 2.0 license, Licensing
- API secret key, Searching for Tweets
- APIs
- providing, Providing an API
- REST (see REST APIs)
- third-party (see third-party APIs)
- Apollo, State Management
- app clusters, scaling out with, Scaling Out with App Clusters-Scaling Out with App Clusters
- app.defaultConfiguration (Express source code), Debugging Express
- app.get() method, Initial Steps, Route Handlers Are Middleware
- app.render() method, Debugging Express
- app.use() method, Initial Steps, Debugging Express
- Artillery, Stress Testing
- assertions, QA testing, Writing Our First Test
- asynchronous functions, debugging, Debugging Asynchronous Functions
- Atom, Editors
- attribution, version control and, Version Control
- Auth0, Passport
- authentication, Authentication-Adding Authentication Providers
- authorization
- AWS CloudFront, Deployment Options
- AWS CodePipeline, Deployment
- AWS Route 53, Security
- Ayima Redirect Path, Initial Steps
- Azure, Cloud Persistence
B
- bash, Using the Terminal
- basicauth-middleware, Common Middleware
- Berkeley Software Distribution (BSD) license, Licensing
- Berners-Lee, Tim, Routing
- best practices, Best Practices
- binary files
- Bing Webmaster Tools, Do Routine QA Checks
- blocks, in Handlebars, Blocks-Blocks
- body-parser middleware, Form Handling with Express, Common Middleware, Debugging Express
- Bootstrap, Form Handling with Express, Using Sessions to Implement Flash Messages
- boutique hosting, Boutique hosting
- breakpoints, Node Inspector Clients
- browser caching, Performance Considerations
- BSD (Berkeley Software Distribution) license, Licensing
- bundlers, Changing Your Static Content
- business logic, presentation versus, Logic Versus Presentation
C
- cache busting, Changing Your Static Content
- Cache-Control header, Caching Static Assets
- caching
- call stack, Node Inspector Clients
- callback function, Middleware Principles
- callbacks, Serving Static Resources
- catastrophic errors, API Error Reporting
- CD (continuous delivery), Deployment
- CDNs (see content delivery networks)
- certificate authorities (CAs), HTTPS
- certificate insurance, Purchasing a Certificate
- certificate signing request (CSR), Purchasing a Certificate
- Chrome
- CI (continuous integration), Continuous Integration
- CircleCI, Deployment
- CJS (CommonJS) modules, Node Modules
- client errors, API Error Reporting
- client-side applications, Server-Side and Client-Side Applications
- (see also single-page applications (SPAs))
- client.query() method, PostgreSQL
- client/server applications, Routing
- cloud development environments, Using the Terminal
- cloud hosting, Traditional hosting or cloud hosting?-Boutique hosting
- cloud storage, Cloud Persistence
- Cloud9, Using the Terminal
- CloudFront, Deployment Options
- cluster.isMaster property, Scaling Out with App Clusters
- cluster.isWorker property, Scaling Out with App Clusters
- CNAME record (DNS), Nameservers
- code coverage, Code Coverage
- code reuse, Code Reuse and Refactoring-Module exposes an object that contains middleware
- CodePipeline, Deployment
- command prompt (see terminal)
- comments, in Handlebars, Comments
- CommonJS (CJS) modules, Node Modules
- components, React, React Basics
- compression middleware, Common Middleware
- Connect, A Brief History of Express
- connection pooling, PostgreSQL
- console (see terminal)
- console logging, Take Advantage of REPL and the Console
- consumer API key, Searching for Tweets
- content delivery networks (CDNs)
- Content-Type headers, Response Headers
- Context API (React), State Management
- context object, Handlebars Basics
- context, templating and, Handlebars Basics
- continuous delivery (CD), Deployment
- continuous integration (CI), Continuous Integration
- controlled components, Sending Information to the Server
- cookie secret, Externalizing Credentials
- cookie-based sessions, Sessions
- cookie-parser middleware, Cookies in Express, Common Middleware
- cookie-session middleware, Common Middleware
- cookies, Cookies and Sessions-Examining Cookies
- CORS (cross-origin resource sharing), Cross-Origin Resource Sharing
- cors package, Cross-Origin Resource Sharing
- country code TLDs, Top-Level Domains
- coverage, of code, Code Coverage
- create-react-app (CRA) utility, Creating a React App, The Home Page, Deployment Options
- createApplication() function (Express source code), Debugging Express
- credentials, externalizing, Externalizing Credentials
- Crockford, Douglas, Linting, JSON and XML
- cross-domain resource sharing, Content Delivery Networks
- cross-origin resource sharing (CORS), Cross-Origin Resource Sharing
- cross-site HTTP requests, Cross-Origin Resource Sharing
- cross-site request forgery (CSRF), Common Middleware, Cross-Site Request Forgery
- cross-site request scripting (XSS) attacks, Cookies and Sessions
- CSR (certificate signing request), Purchasing a Certificate
- CSS
- csurf middleware, Common Middleware, Cross-Site Request Forgery
- Ctrl-Q, Using the Terminal
- Ctrl-S, Using the Terminal
- curly brackets ({{ }}), Comments-Blocks
- current working directory (cwd), Node Inspector Clients
D
- Dahl, Ryan, The JavaScript Revolution
- databases
- abstracting the database layer, Abstracting the Database Layer-Abstracting the Database Layer
- adding data to MongoDB, Adding Data-Adding Data
- adding data to PostgreSQL, Adding Data
- connections with Mongoose, Database Connections with Mongoose
- creating schemas and models, Creating Schemas and Models
- file systems versus, Filesystem Persistence
- MongoDB setup, Setting Up MongoDB
- Mongoose setup, Mongoose
- optimization of NoSQL databases, A Note on Performance
- persistence, Database Persistence-Adding Data
- PostgreSQL, PostgreSQL-PostgreSQL
- retrieving data, Retrieving Data-Retrieving Data
- seeding initial data, Seeding Initial Data-Seeding Initial Data
- session storage, Using a Database for Session Storage-Using a Database for Session Storage
- storing user records in, Storing Users in Your Database
- debugging, Debugging-Conclusion
- delegated authentication, Third-Party Authentication
- deployment, Deployment-Manual Git-based deployment
- development environments, cloud-based, Using the Terminal
- DigitalOcean, The behemoths
- directory structure conventions, File and Directory Structure
- distributed version control systems (DVCSs), Version Control
- DNS (Domain Name System), Domain Name System
- document databases, Database Persistence
- documentation
- DOM (Document Object Model), Server-Side and Client-Side Applications
- domain certificates, Purchasing a Certificate
- Domain Name System (DNS), Domain Name System
- domain names, Domain Registration and Hosting
- domain registration, Domain Registration and Hosting-Nameservers
- dot net, The JavaScript Revolution
- dual licensing, Licensing
- DVCSs (distributed version control systems), Version Control
- dynamic content
- dynamic IP address, Nameservers
E
- ECMA-262 ECMAScript language specification, Online Documentation
- ECMAScript Modules (ESM), Node Modules
- edge caching, Content Delivery Networks
- editors, Editors
- ElephantSQL, PostgreSQL
- elimination, process of, The First Principle of Debugging
- Emacs, Editors
- email, Sending Email-Conclusion
- bulk options other than Nodemailer, Better Options for Bulk Email
- encapsulating functionality, Encapsulating Email Functionality
- formats, Email Formats
- headers, Email Headers
- HTML format, HTML Email
- images in HTML email, Images in HTML Email
- Nodemailer package, Nodemailer-Sending Mail to Multiple Recipients
- receiving, Receiving Email
- sending HTML email, Sending HTML Email-Encapsulating Email Functionality
- sending HTML email with views, Using Views to Send HTML Email-Using Views to Send HTML Email
- sending to multiple recipients, Sending Mail to Multiple Recipients
- sending to single recipient, Sending Mail
- SMTP, MSAs, and MTAs, SMTP, MSAs, and MTAs
- Email Boilerplate, HTML Email
- Ember, SPA Technologies
- encapsulation of email functionality, Encapsulating Email Functionality
- encoding of forms, Encoding
- entropic functionality, Code Coverage
- environment-specific configuration, Environment-Specific Configuration-Environment-Specific Configuration
- error handling/reporting
- errorhandler middleware, Middleware Principles, Common Middleware
- ESLint, Linting-Linting
- ESM (ECMAScript Modules), Node Modules
- ETag header, Caching Static Assets
- event-driven programming, Event-Driven Programming
- exceptions, uncaught, Handling Uncaught Exceptions
- execution environments, Execution Environments, Environment-Specific Configuration-Environment-Specific Configuration
- Expires header, Caching Static Assets
- exports variable, Node Modules
- Express
- additional learning resources for, Additional Resources-Conclusion
- APIs provided by, Using Express to Provide an API
- basics, Saving Time with Express-Conclusion
- brief history, A Brief History of Express
- contributing to, Contributing to Express-Contributing to Express
- cookies in, Cookies in Express
- debugging, Debugging Express-Conclusion
- enabling HTTPS for Express app, Enabling HTTPS for Your Express App
- features, Introducing Express
- form handling with, Form Handling with Express-Form Handling with Express
- layouts in, Views and Layouts
- online documentation, Online Documentation
- scaffolding, Scaffolding
- submitting pull requests, Contributing to Express-Contributing to Express
- express-handlebars, Views and Layouts, Server-Side Templates
- express-session middleware, Memory Stores, Common Middleware
- express.Router(), Subdomains
- extended valuation, Purchasing a Certificate
- externalizing credentials, Externalizing Credentials
F
- FaaS (functions as a service), XaaS
- Facebook
- Facebook app, Setting up Passport-Setting up Passport
- federated authentication, Third-Party Authentication
- Fetch
- file structure conventions, File and Directory Structure
- file uploads, File Uploads-Improving File Upload UI
- filesystem persistence, Filesystem Persistence-Filesystem Persistence
- financial computations, in JavaScript, Creating Schemas and Models
- find() method, Mongoose, Seeding Initial Data
- flash messages, Using Sessions to Implement Flash Messages-Using Sessions to Implement Flash Messages
- flat files, Filesystem Persistence
- floating-point numbers, Creating Schemas and Models
- Forever, Running Your Node Process
- form handling, Form Handling-Conclusion
- FormData object, File Uploads with Fetch
- forward-facing proxy, Scaling Out with Multiple Servers
- fragment, in URL, The Parts of a URL
- fs.readFile, Serving Static Resources
- FTP, security issues with, Deployment
- fully qualified domain name (FQDN), Generating Your Own Certificate
- functionality (QA element), QA: Is It Worth It?
- functions as a service (FaaS), XaaS
G
- GA (Google Analytics), Monitor Analytics
- general TLDs (gTLDs), Top-Level Domains
- geocoding, Geocoding-Displaying a Map
- geographic optimization, Content Delivery Networks
- GET request, HTTP Request Methods, Sending Client Data to the Server
- Git
- git add command, If You’re Following Along by Doing It Yourself
- Git bash shell, Using the Terminal
- GNU General Public License (GPL), Licensing, Contributing to Express
- going live, Going Live-Conclusion
- Google
- Google Analytics (GA), Monitor Analytics
- Google Cloud Build, Deployment
- Google PageSpeed Insights, Optimize Performance
- Google Webmaster Tools, Do Routine QA Checks
- GPL (GNU General Public License), Licensing, Contributing to Express
- gTLDs (general TLDs), Top-Level Domains
H
- Handlebars, Views and Layouts
- handlers (see route handlers)
- HAProxy, Scaling Out with Multiple Servers
- hash, in URL, The Parts of a URL
- HCI (human-computer interaction), QA: Is It Worth It?
- headers
- Heroku, The behemoths
- Holowaychuk, TJ, A Brief History of Express, Pug: A Different Approach
- hooks, React, Vacations Page—Visual Design, Vacations Page—Server Integration
- host, in URL, The Parts of a URL
- hosting, Hosting-Boutique hosting
- HTML
- HTML email
- HTML forms, HTML Forms
- HTML5 Boilerplate, Perfecting Your Templates
- HTML5, online documentation for, Online Documentation
- HTTP
- HTTP APIs, API Error Reporting
- http.createServer method, Event-Driven Programming
- http.ServerResponse object, The Response Object
- HTTPS (HTTP Secure), HTTPS-HTTPS and Proxies
- human-computer interaction (HCI), QA: Is It Worth It?
- hygiene (development), Exercise Good Hygiene
I
- IaaS (infrastructure as a service), XaaS
- ICANN (Internet Corporation for Assigned Names and Numbers), Top-Level Domains
- images, in HTML email, Images in HTML Email
- information architecture (IA), Routing
- infrastructure as a service (IaaS), XaaS
- inspector clients, Node Inspector Clients-Node Inspector Clients
- install command, npm
- installation
- institutional procrastination, Don’t Procrastinate
- integration testing, Overview of QA Techniques, Integration Testing-Integration Testing
- Internet Corporation for Assigned Names and Numbers (ICANN), Top-Level Domains
- internet media types, Internet Media Types
- invisible failures, Prevent “Invisible” Failures
- IP (internet protocol) address, Domain Registration and Hosting
- issue trackers, Use an Issue Tracker
L
- Last-Modified header, Caching Static Assets
- launching a website (see going live)
- layouts, Views and Layouts-Views and Layouts
- lead tracking, Prioritize Lead Tracking-Prioritize Lead Tracking
- learning resources, Additional Resources-Conclusion
- Let's Encrypt, Using a Free Certificate Authority
- lib/application.js (Express source code), Getting More Information, Debugging Express
- lib/express.js (Express source code), Getting More Information, Debugging Express
- lib/request.js (Express source code), Getting More Information, Debugging Express
- lib/response.js (Express source code), Getting More Information, Debugging Express
- lib/router/route.js (Express source code), Getting More Information
- licensing, Licensing
- linting, Linting-Linting
- Linux
- load testing (stress testing), Stress Testing
- local storage, sessions and, Sessions
- localhost, A Simple Web Server with Node
- LockIt, Passport
- logger middleware source, Debugging Express
- logging, Environment-Specific Configuration, Prevent “Invisible” Failures
- logic (business logic), presentation versus, Logic Versus Presentation
- longevity plan, Have a Longevity Plan-Have a Longevity Plan
- lossless/lossy size reduction, Performance Considerations
M
- macOS
- mail submission agent (MSA), SMTP, MSAs, and MTAs
- mail transfer agent (MTA), SMTP, MSAs, and MTAs
- maintenance, Maintenance-Conclusion
- code reuse and refactoring, Code Reuse and Refactoring-Module exposes an object that contains middleware
- hygiene and, Exercise Good Hygiene
- issue tracker, Use an Issue Tracker
- lead tracking, Prioritize Lead Tracking-Prioritize Lead Tracking
- longevity plan and, Have a Longevity Plan-Have a Longevity Plan
- monitor analytics, Monitor Analytics
- performance optimization, Optimize Performance
- prevention of invisible failures, Prevent “Invisible” Failures
- principles of, Have a Longevity Plan-Prevent “Invisible” Failures
- procrastination as threat to, Don’t Procrastinate
- QA checks, Do Routine QA Checks
- source control, Use Source Control
- maps, displaying, Displaying a Map
- Markdown, Stack Overflow
- master pages (see layouts)
- MDN (Mozilla Developer Network), Online Documentation
- Meadowlark Travel website (fictional example)
- MEAN (Mongo, Express, Angular, and Node) stack, The Node Ecosystem
- metadata storage, Project Metadata
- method-override middleware, Common Middleware
- Microsoft
- Microsoft Azure, Cloud Persistence, Deployment
- middleware, Middleware-Conclusion
- minification (see bundlers)
- MIT license, Licensing, Contributing to Express
- mLab, Setting Up MongoDB
- MobX, State Management
- mocking, Mocking
- models, Creating Schemas and Models
- modularization (see Node modules)
- modules
- modules/express-session/index.js (middleware source code), Debugging Express
- modules/morgan/index.js, Debugging Express
- MongoDB
- MongoDB Atlas, Setting Up MongoDB
- Mongoose
- morgan middleware, Common Middleware, Environment-Specific Configuration
- Mozilla Developer Network (MDN), Online Documentation
- MSA (mail submission agent), SMTP, MSAs, and MTAs
- MTA (mail transfer agent), SMTP, MSAs, and MTAs
- multimedia, as static content, Static Content
- multipart form handling, File Uploads-Improving File Upload UI
- multiparty middleware, File Uploads-File Uploads, Common Middleware
- multisubdomain certificates, Purchasing a Certificate
N
- Name.com, Security
- Namecheap.com, Security
- nameservers, Nameservers
- National Weather Service (NWS) API, Weather Data-Weather Data
- next() function, Middleware Principles
- NGINX, Scaling Out with Multiple Servers, HTTPS and Proxies
- Node
- as single threaded, Node: A New Kind of Web Server
- basics, Node: A New Kind of Web Server-Node: A New Kind of Web Server
- debugger, Using Node’s Built-in Debugger
- ecosystem, The Node Ecosystem
- editors with, Editors
- event-driven programming as core philosophy, Event-Driven Programming
- exposing middleware, Middleware
- getting started with, Getting Started with Node-Onward to Express
- inspector clients, Node Inspector Clients-Node Inspector Clients
- installation, Getting Node
- licensing when developing applications for, Licensing
- npm and, npm
- online documentation, Online Documentation
- origins, The JavaScript Revolution
- platform independence of, Node: A New Kind of Web Server
- simple web server project, A Simple Web Server with Node-Serving Static Resources
- terminal for, Using the Terminal
- node modules, npm Packages
- Node modules, Node Modules-Node Modules
- node-fetch package, Our Tests
- Nodemailer, Nodemailer-Sending Mail to Multiple Recipients, Sending HTML Email
- node_modules/body-parser/lib/types/urlencoded.js, Debugging Express
- node_modules/serve-static/index.js (Express source code), Debugging Express
- NoSQL databases, Database Persistence
- npm (package manager), npm
- NWS (National Weather Service) API, Weather Data-Weather Data
P
- PaaS (platform as a service), XaaS
- package managers (see npm)
- package-lock.json, npm Packages
- package.json file, Initial Steps
- PageSpeed Insights, Optimize Performance
- Parcel, Changing Your Static Content
- partials, Partials-Partials
- Passport
- passwords, The Problem with Passwords
- path(s)
- PEM (Privacy-Enhanced Electronic Mail) file, Generating Your Own Certificate
- performance optimization
- periodicals, Periodicals
- persistence, Persistence-Conclusion
- Pilgrim, Mark, Online Documentation
- pipeline, Middleware
- platform as a service (PaaS), XaaS
- platform independence, Node: A New Kind of Web Server
- PM2, Running Your Node Process
- Polymer, SPA Technologies
- ports
- POST request, HTTP Request Methods
- PostgreSQL, PostgreSQL-PostgreSQL
- PowerShell, Using the Terminal
- presentation, logic versus, Logic Versus Presentation
- Privacy-enhanced Electronic Mail (PEM) file, Generating Your Own Certificate
- process managers, Running Your Node Process
- process of elimination, The First Principle of Debugging
- process.nextTick, Handling Uncaught Exceptions
- processing forms, Processing Forms
- procrastination, Have a Longevity Plan, Don’t Procrastinate
- production concerns, Production Concerns-Conclusion
- protocol, in URL, The Parts of a URL
- proxies, Scaling Out with Multiple Servers, HTTPS and Proxies
- public key certificate, HTTPS
- Pug, Views and Layouts, Pug: A Different Approach
- Puppeteer, Integration Testing-Integration Testing
Q
- quality assurance (QA), Quality Assurance-Continuous Integration
- continuous integration, Continuous Integration
- creating a plan for, The QA Plan
- integration testing, Integration Testing-Integration Testing
- Jest installation/configuration, Installing and Configuring Jest
- linting, Linting-Linting
- logic versus presentation, Logic Versus Presentation
- maintenance and, Do Routine QA Checks
- overview of techniques, Overview of QA Techniques
- test types, The Types of Tests
- value of, QA: Is It Worth It?
- querystring
R
- RDBMS (relational database management system), Database Persistence, PostgreSQL
- reach (QA element), QA: Is It Worth It?
- React
- about, SPA Technologies
- basics, React Basics-Deployment Options
- creating app with, Creating a React App
- homepage, The Home Page
- routing, Routing-Routing
- sending information to the server, Sending Information to the Server-Sending Information to the Server
- server integration for vacations page, Vacations Page—Server Integration-Vacations Page—Server Integration
- SPA deployment options, Deployment Options
- state management, State Management
- visual design for vacations page example, Vacations Page—Visual Design
- React Context, State Management
- React hooks, Vacations Page—Visual Design, Vacations Page—Server Integration
- React Router library, Routing-Routing
- read-eval-print loop (REPL), Take Advantage of REPL and the Console
- recoverable errors, API Error Reporting
- Redirect Path, Initial Steps
- Redis, Using a Database for Session Storage
- Redux, State Management
- refactoring, Middleware
- registration
- regular expressions (regex), Route Paths and Regular Expressions
- relational database management system (RDBMS), Database Persistence, PostgreSQL
- REPL (read-eval-print loop), Take Advantage of REPL and the Console
- req.accepts() method, The Request Object
- req.body object, The Request Object, Processing Forms
- req.clearCookie object, Cookies in Express
- req.cookies object, The Request Object, Rendering Content, Cookies in Express
- req.headers object, The Request Object
- req.hostname method, The Request Object
- req.ip parameter, The Request Object, Scaling Out with Multiple Servers
- req.ips array, Scaling Out with Multiple Servers
- req.originalUrl property, The Request Object
- req.params array, The Request Object
- req.path parameter, The Request Object
- req.protocol property, The Request Object, Scaling Out with Multiple Servers
- req.query object, The Request Object, Rendering Content, Form Handling with Express
- req.route parameter, The Request Object
- req.secure property, The Request Object, Scaling Out with Multiple Servers
- req.signedCookies object, The Request Object, Rendering Content, Cookies in Express
- req.url property, The Request Object
- req.xhr property, The Request Object, Processing Forms
- request body, Request Body
- request headers, Request Headers
- request objects
- require() function, Node Modules
- res.attachment(), The Response Object
- res.cookie(), The Response Object
- res.download(), The Response Object
- res.end(), The Response Object
- res.format(), The Response Object, Providing an API
- res.json(), The Response Object
- res.jsonp(), The Response Object
- res.links(), The Response Object
- res.locals object, The Response Object
- res.locals.flash object, Using Sessions to Implement Flash Messages
- res.redirect(), The Response Object
- res.render(), The Response Object, Rendering Content, Using Views to Send HTML Email
- res.send(), Initial Steps, The Response Object, Rendering Content, Debugging Express
- res.sendFile(), The Response Object
- res.set(), The Response Object
- res.status(), The Response Object
- res.type(), The Response Object
- resources (see learning resources)
- response headers, Response Headers, Internet Media Types
- response objects
- response-time middleware, Common Middleware
- REST APIs, REST APIs and JSON-Conclusion
- REST/RESTful, defined, REST APIs and JSON
- reverse proxy, Scaling Out with Multiple Servers
- role-based authorization, Role-Based Authorization-Role-Based Authorization
- Rollup, Changing Your Static Content
- root directory, Initial Steps
- Route 53, Security
- route handlers
- route parameters, Route Parameters
- routing, Routing, Routing-Conclusion
- automatically rendering views, Automatically Rendering Views
- basics, Routing-Routing
- declaring routes in a module, Declaring Routes in a Module
- grouping handlers logically, Grouping Handlers Logically
- organizing routes, Organizing Routes
- pipeline and, Middleware
- React apps, Routing-Routing
- route handlers as middleware, Route Handlers Are Middleware
- route parameters, Route Parameters
- route paths and regular expressions, Route Paths and Regular Expressions
- SEO and, Routes and SEO
- subdomains, Subdomains-Subdomains
- Ruby, The JavaScript Revolution, Scaffolding
- Ruby on Rails, Scaffolding
S
- S3, Cloud Persistence, Deployment Options
- SaaS (software as a service), XaaS
- save() method, Mongoose, Seeding Initial Data
- scaffolding, Scaffolding
- scaling out
- schemas, Creating Schemas and Models
- scope variables, Node Inspector Clients
- scripts, in package.json file, Installing and Configuring Jest
- search engine optimization (SEO), Server-Side and Client-Side Applications, Routes and SEO
- sections, Sections
- security, Security-Conclusion
- semantic versioning, npm Packages
- Semaphore, Deployment
- semicolons, Hello World
- SendGrid, Sending Mail to Multiple Recipients
- Sentry, Handling Uncaught Exceptions
- SEO (search engine optimization), Server-Side and Client-Side Applications, Routes and SEO
- serve-favicon middleware, Common Middleware
- serve-index middleware, Common Middleware
- server integration, Vacations Page—Server Integration-Vacations Page—Server Integration
- server routing (see routing)
- server, sending information to, Sending Information to the Server-Sending Information to the Server
- server-side applications, Server-Side and Client-Side Applications
- server-side rendered (SSR) applications, Server-Side and Client-Side Applications
- server-side templates, Server-Side Templates
- session middleware, Debugging Express
- sessions, Sessions-What to Use Sessions For
- Set-Cookie header, Cookies and Sessions
- Simple Mail Transfer Protocol (SMTP), SMTP, MSAs, and MTAs, Nodemailer
- Sinatra, A Brief History of Express
- single-domain certificates, Purchasing a Certificate
- single-page applications (SPAs), Server-Side and Client-Side Applications, Single-Page Applications
- CDNs and, Single-Page Applications
- deployment options, Deployment Options
- homepage, The Home Page
- origins, A Short History of Web Application Development-A Short History of Web Application Development
- routing, Routing-Routing
- sending information to the server, Sending Information to the Server-Sending Information to the Server
- server integration, Vacations Page—Server Integration-Vacations Page—Server Integration
- state management, State Management
- technology choices, SPA Technologies
- visual design, Vacations Page—Visual Design
- web application development history, A Short History of Web Application Development-Conclusion
- SMTP (Simple Mail Transfer Protocol), SMTP, MSAs, and MTAs, Nodemailer
- SO (Stack Overflow), Stack Overflow-Stack Overflow
- social media, Social Media-Rendering Tweets
- software as a service (SaaS), XaaS
- source control, Use Source Control
- (see also version control)
- SPAs (see single-page applications)
- spoofing, Email Headers
- SpritePad, Performance Considerations
- SSL (public key) certificate, HTTPS
- Stack Overflow (SO), Stack Overflow-Stack Overflow
- state
- static content, Static Content-Conclusion
- static IP address, Nameservers
- static middleware, Static Files and Views, Common Middleware, Server-Rendered Website, Debugging Express
- static resources, Serving Static Resources-Serving Static Resources
- staticMiddleware() function, Debugging Express
- storage (see databases) (see persistence)
- stress testing, Stress Testing
- subdomains, Subdomains
- subdomains, in URL, The Parts of a URL
T
- technical debt, Don’t Procrastinate
- template caching, Server-Side Templates
- templating, Templating with Handlebars-Conclusion
- avoiding HTML, There Are No Absolute Rules Except This One
- basics, Templating with Handlebars
- blocks, Blocks-Blocks
- comments, Comments
- criteria for choosing a template engine, Choosing a Template Engine
- partials, Partials-Partials
- perfecting templates, Perfecting Your Templates
- Pug approach to, Pug: A Different Approach
- sections, Sections
- server-side templates, Server-Side Templates
- using layouts in Express, Views and Layouts
- views and layouts, Views and Layouts
- terminal, Using the Terminal
- third-party APIs
- third-party authentication, Third-Party Authentication, Authentication Versus Registration and the User Experience
- third-party confusion, Authentication Versus Registration and the User Experience
- top-level domains (TLDs), Top-Level Domains
- Travis CI, Continuous Integration, Deployment
- trusted root certificates, HTTPS
- Twitter
U
- Ubuntu Linux, Using the Terminal
- UI (user interface), for file upload, Improving File Upload UI
- uncaught exceptions, Handling Uncaught Exceptions
- uncaughtException event, Handling Uncaught Exceptions
- unit testing
- uploading files, File Uploads-Improving File Upload UI
- uptime monitors, Third-Party Uptime Monitors
- UptimeRobot, Third-Party Uptime Monitors
- URLs, Routing
- usability (QA element), QA: Is It Worth It?
- user experience, registration and, Authentication Versus Registration and the User Experience
- user interface (UI), for file upload, Improving File Upload UI
V
- version control, Version Control
- (see also source control)
- vhost middleware, Common Middleware, Subdomains
- view model, Retrieving Data
- views, Views and Layouts-Views and Layouts
- vim, Editors
- virtual machines (VMs), Using the Terminal
- VirtualBox, Using the Terminal
- virtualization, Traditional hosting or cloud hosting?
- Visual Studio Code, Editors, Node Inspector Clients
- Vue.js, SPA Technologies
W
- watch expressions, Node Inspector Clients
- weather data, Weather Data-Weather Data
- web application development, brief history of, A Short History of Web Application Development-A Short History of Web Application Development
- Web Apps (Microsoft Azure), Deployment
- web server project
- web service, defined, REST APIs and JSON
- Webpack, The JavaScript Revolution, Changing Your Static Content
- webpack-dev-server, Deployment Options
- websites
- WHATWG, Online Documentation
- widgets, Partials
- wildcard certificates, Purchasing a Certificate
- Windows
..................Content has been hidden....................
You can't read the all page of ebook, please click
here login for view all page.