Chapter 01 Node.js Platform

1-1 Node.js Philosophy
1-2 How Node.js Works
1-3 JavaScript in Node.js
summation

Chapter 02 Module System

2-1 The Need for Modules
2-2 Module System in JavaScript and Node.js
2-3 Module Systems and Patterns
2-4 CommonJS modules
2-5 Module Definition Pattern
2-6 ESM: ECMAScript Module
2-7 Differences and Interoperability between ESM and CommonJS
summation

Chapter 03 Callbacks and Events

3-1 Callback Pattern
3-2 The observer pattern
summation

Chapter 04 Asynchronous Control Flow Patterns Using Callbacks

4-1 The Difficulties of Asynchronous Programming
4-2 Callback Best Practices and Control Flow Patterns
4-3 Asynchronous Library
summation

Chapter 05 Asynchronous Control Flow Patterns with Promises and Async/Await

5-1 Promise
5-2 Async/await
5-3 The problem of infinite recursive promise resolution chains
summation

Chapter 06 Stream Coding

Discovering the importance of stream 6-1
6-2 Starting the Stream
Asynchronous Control Flow Patterns Using 6-3 Streams
6-4 Piping Pattern
summation

Chapter 07 Constructor Design Pattern

7-1 Factory
7-2 Builder
7-3 Public Constructor
7-4 singleton
7-5 Module Wiring
summation

Chapter 08 Structural Design Patterns

8-1 Proxy
8-2 Decorator
8-3 The boundary between proxies and decorators
8-4 adapter
summation

Chapter 09 Behavioral Design Patterns

9-1 Strategy Pattern
9-2 State
Template 9-3
9-4 Iterator
9-5 Middleware
9-6 Command
summation

Chapter 10 General-Purpose JavaScript for Web Applications

10-1 Sharing Code with Browsers
10-2 Cross-Platform Development Fundamentals
10-3 React Overview
10-4 Building a Universal JavaScript App
summation

Chapter 11 Advanced Recipes

11-1 Handling Asynchronously Initialized Components
11-2 Asynchronous Request Batching and Caching
11-3 Canceling Asynchronous Tasks
11-4 Executing CPU-bound tasks
summation

Chapter 12 Scalability and Architectural Patterns

12-1 Introduction to Application Extensions
12-2 Replication and Load Balancing
12-3 Decomposing Complex Applications
summation

Chapter 13 Messaging and Integration Patterns

13-1 Messaging System Fundamentals
13-2 Publish/Subscribe Pattern
13-3 Task Distribution Pattern
13-4 Request/Reply Pattern
summation

This book is intended for developers who are new to Node.js and want to get the most out of it in terms of productivity, design quality, and scalability.
This book will cover some basic concepts, so you only need to have some familiarity with the JavaScript language to work through the basic examples.
The techniques presented in this book will also be useful to intermediate Node.js developers.
A background in software design theory will also be helpful in understanding some of the concepts presented.
This book assumes a working knowledge of web application development, web services, databases, and data structures.

Chapter 1.
'The Node.js Platform' serves as an overview of the world of Node.js application design by showcasing the core patterns of the platform itself.
Covers the Node.js ecosystem and its philosophy, providing a quick introduction to Node.js internals and the reactor pattern.
Chapter 2.
In 'Module System', we look at the module systems available in Node.js and highlight the differences between CommonJS and the modern ES modules introduced in ECMAScript 2015.
Chapter 3.
In 'Callbacks and Events', we learn about asynchronous coding and patterns, discuss callbacks and event emitters (the observer pattern), and introduce the first steps for comparison.

Chapter 4.
'Asynchronous Control Flow Patterns with Callbacks' introduces a set of patterns and techniques for efficiently handling asynchronous control flow in Node.js using callbacks.
This chapter describes some traditional ways to mitigate the “callback hell” problem using plain JavaScript.
Chapter 5.
'Asynchronous Control Flow Patterns with Promises and Async/Await' progresses by exploring more sophisticated and modern techniques for asynchronous flow control.
Chapter 6.
'Stream Coding' goes into detail about streams, one of the most important tools for Node.js.
Shows how to transform and process data with Transform streams and how to combine streams in different patterns.

Chapter 7.
In 'Constructor Design Pattern', we begin to explore traditional design patterns in Node.js.
In this chapter, we will look at the most widely used creational patterns: the Factory pattern, the Revealing Constructor pattern, the Builder pattern, and the Singleton pattern.
Chapter 8.
In 'Structural Design Patterns', we continue to explore traditional design patterns in Node.js, covering structural design patterns such as Proxy, Decorator, and Adapter.
Chapter 9.
'Behavioral Design Patterns' introduces behavioral design patterns such as Strategy, State, Template, Middleware, Command, and Iterator, and concludes the discussion of traditional design patterns in Node.js.

Chapter 10.
'Universal JavaScript for Applications' explores one of the most exciting features of modern JavaScript web applications: the ability to share code between the frontend and backend.
In this chapter, you'll learn the fundamentals of general-purpose JavaScript by building a simple web application using modern tools and libraries.
Chapter 11.
Advanced Recipes demonstrate how to use problem-solving methods to derive ready-to-use solutions from common coding and design complexities.
Chapter 12.
'Extensibility and Structural Patterns' describes the fundamental techniques and patterns for scaling Node.js applications.
Chapter 13.
'Messaging and Integration Patterns' introduces the most important messaging patterns and shows how to build and integrate complex distributed systems using Node.js and its ecosystem.