Building Production-ready Web Apps with Node.js: A Practitioner’s Approach to produce Scalable, High-performant, and Flexible Web Components

Cover Page
Title Page
Copyright Page
Dedication Page
About the Author
About the Reviewer
Acknowledgement
Preface
Errata
Table of Contents
1. Getting Started with the Fundamentals
	Structure
	Objective
	Introduction to event-driven architecture
		Calculator example
		Number sorting example
		Echo example
		Web page access example
		Web server example
		Windows event loop
		Messaging example
	Introduction to asynchronous programming
		Program interrupt example
		Multimedia example
		JavaScript web page example
		Operating system scheduler example
	Introduction to functional programming
		Function passed as a value
		Function returned as a result
		Function as assignment subject
		Closure functions
		Closure context
	Concurrency
		Cooking example
		Progress bar example
		Garbage collection
	Parallelism
		Distributed word counting example
	Concurrency versus parallelism
		Similarity
		Differences
	Concurrency and scalability
		Thread pooling
		Horizontal scaling
	Introduction to Node.js
		Latency in computer systems
		CPU bound and I/O bound operations
		Characteristics of web workload
		Bringing the context of scalability
		Bringing back the context of asynchronous programming
		Bring back the context of event-driven architecture
		Bring back the context of functional programming
	Core Node.js features
		Structure
		APIs
		Streams
		Small core philosophy
		npm
	Conclusion
	Points to remember
2. Setting Up the Environment
	Structure
	Objective
	Platform selection
	Node.js version selection
	Dependencies selection
	Resource requirements
	Code editor selection
	Conclusion
3. Introduction to Web Server
	Structure
	Objective
	Introduction to web server
		Core components
			Client
			Web layer
			Middleware
			Business logic layer
			The microservice layer
	Concerns and considerations of web servers
		Comparison of a desktop and a web server
			Similarities
			Differences
	Web server considerations: Architecture
		Microservice architecture
	Web server considerations: Performance
		Performance overheads
		Best practices
	Web server considerations: Security
		Security threat types
		Best practices
	Web server considerations: Reliability
		Examples of reliability issues
		Best practices
	Web server considerations: Extensibility
		Examples of extensibility
		Best practices
	Web server considerations: Maintainability
		Importance of maintainability
		Best practices
	Web server considerations: Serviceability
		Best practices
	Web server considerations: Observability
		Importance of observability
		Best practices
	Conclusion
4. Our First Program: Time of the Day Server
	Structure
	Objective
	A ‘hello world!’ server
		Running the program
		Accessing the server through the browser
	A Time of the Day Server
		Program sections
			Require statement
			The server loop
			The date
			The server response
			The server listen
	Conclusion
	Exercises
		Problem #1
		Problem #2
5. Common Networking Interfaces of Node.js
	Structure
	Objective
	Network programming
	Why a protocol?
		At the calling function side
		At the called function side
	TCP/IP
	HTTP
		POST
		/ verb
		HTTP/1.1
		Host
		Content-Type
		Content-Length
	Node.js streams
	Node.js buffers
	Request and response objects
		Request
		Response
	Request and response life cycle
		Request life cycle
			‘aborted’
			‘close’
			‘data’
			‘end’
		Response life cycle
			‘close’
			‘finish’
	Server configuration
		‘maxHeadersCount’
		‘timeout’
	Server’s life cycle events
		‘listening’
			‘connect’
			‘close’
	Other networking APIs
		HTTPS
		HTTP 2
		UDP
	Conclusion
6. Major Web Server Components
	Structure
	Objective
	Introduction
	A static file server
		Use case
		Definition
		Implementation
	HTTP verbs (request methods)
		Use case
		Definition
		Implementation
	Route
		Use case
		Definition
		Implementation
	Endpoints
	Cookie
		Use case
		Definition
		Implementation
		Cookie attributes
	Session
		Use case
		Definition
		Implementation
	Request forwarding
		Use case
		Definition
		Implementation
	Multipart form-data
		Use case
		Definition
		Implementation
	Body parser
		Use case
		Definition
		Implementation
	Cross-Origin Resource Sharing (CORS)
		Use case
		Definition
		Implementation
	Dynamic web page
		Use case
		Definition
		Implementation
	HTTP status codes
		Use case
		Definition
		Implementation
	Server security
		Use case
		Definition
		Implementation
			Data privacy and integrity
			Cross-Site Scripting (XSS)
			(Distributed or non-distributed) Denial of Service
			Brute force (weak authentication)
	Conclusion
7. Interacting with Backend Components
	Structure
	Objective
	Backend components: internal services
		Intent
		Design considerations
			Functional
			Performance
			Reliability
			Security
			Serviceability
	Backend components: external services
		Intent
		Design considerations
			Functional
			Performance
			Reliability
			Security
			Serviceability
	Backend components: database
		Intent
		Design considerations
			Functional
			Performance
			Database end
			Web server end
			Reliability
			Security
		Serviceability
	Conclusion
8. Implementing Common Website Features
	Structure
	Objective
	History of web pages
	Website – design considerations
		Usability
			Registered and unregistered views
			Navigation bar
			Articles
			Headers and footers
			Forms
			Search option
			Feedback forms
			Shopping carts
			Payment options
			Ease of use
			Consistent pages
			Short pages
			Short forms
			Home page
			Responsive web forms
	Website – elements and components
		By language
			HTML
			CSS
			JavaScript
		By elements
			DOM
			XMLHttpRequest
			WebSocket
			WebWorker
		By components
			Hyperlink
			Article
			Dialog
			Form
			Options/dropdown
			Table
			Image
			Audio
			Video
			Script
	Website: Advanced features
		Google APIs
		Embedding: Maps and social media
		Pagination
		Search
		Filters
		Geolocation indexing
		Authentication
		Admin dashboard
		User profile
	Conclusion
9. Making Our Website Production Grade
	Structure
	Objective
	Enterprise enabling components
		Performance
		Reliability
			Issue
		Remediation
			Issue
			Remediation
			Issue
			Remediation
			Issue
			Remediation
			Issue
			Remediation
			Issue
			Remediation
			Issue
			Remediation
			Issue
			Remediation
			Issue
			Remediation
			Issue
			Remediation
			Issue
			Remediation
		Availability
			Issue
			Remediation
			Issue
			Remediation
			Issue
			Remediation
			Issue
			Remediation
			Issue
			Remediation
			Issue
			Remediation
		Scalability
			Vertical scalability
			Issue
			Remediation
			Issue
			Remediation
			Horizontal scalability
		Observability
			Trace (also known as log)
			Profiling/monitoring
			Dumping/snapshotting
		Security
			Input validation
			Secure headers
			Secure sessions
			Authentication and authorization
			Data encryption
			Audit logging (aka logging for security)
			File system protection
			Shutdown unwanted ports
		Documentation
	Conclusion
10. Best Practices for High Performant Code
	Structure
	Objective
	Performance best practice: Hardware
		CPU
		Cache
		Disk
	Performance best practice: Network
	Performance best practice: Operating system
	Performance best practice: Runtime (Node.js)
		Garbage collection
		Event loop
		Concurrency: “sync” versus “async”
		Increasing concurrency
		Remove debug options
	Performance best practice: Application
		Content optimization
		Application decoupling
		HTTP caching
		API selection
		Miscellaneous
	Conclusion
11. Debugging Program Anomalies
	Structure
	Objective
	Debugging crash
		Preparation
		Symptom
		Useful data
		Problem determination
	Debugging low CPU
		Preparation
		Symptom
		Useful data
		Problem determination
	Debugging high CPU
		Preparation
		Symptom
		Useful data
		Problem determination
	Debugging memory
		Preparation
		Symptom
		Useful data
		Problem determination
	Debugging performance degradation
		Preparation
		Symptom
		Useful data
		Problem determination
	Conclusion
	End
Index