Node.js Build Web APIs and Applications With Node.js (Rufus Stewart) (Z-Library)

【One-Line Pitch】 A hands-on, beginner-friendly guide that takes you from installing Node.js to building a modular web application with an HTTP server, router, and request handlers—perfect for developers with some JavaScript or backend experience who want to understand how Node really works under the hood. 【Book Arc】 - **Opening (~0%–9%)**: Introduces Node.js as a JavaScript runtime built on Chrome's V8 engine, explains why it's different from browser JavaScript, and walks through installation (recommending version managers over binaries), verifying setup with `node -v`, and writing a first "Hello, World!" script. Also covers npm basics, including global package installation and linting with jshint. - **Early (~9%–16%)**: Shifts to mindset—why JavaScript on the server matters and what it means to move from frontend tinkering to backend development. Sets up a concrete project goal (an image upload app) and deliberately adds extra abstraction to teach scalable architecture, breaking the app into an HTTP server, router, and request handlers. - **Early (~16%–28%)**: Builds the first real components: a basic HTTP server in `server.js`, a main entry file `index.js`, and explains how Node modules work with `require` and `exports`. Introduces callbacks by showing how functions can be passed as arguments, and covers parsing URLs with the `url` and `querystring` modules. - **Middle (~28%–38%)**: Connects server, router, and request handlers through dependency injection. Shows how to pass a `handle` object (mapping URL paths to handler functions) into the router, achieving loose coupling. Includes a detour into functional programming concepts, referencing Steve Yegge's "Execution in the Kingdom of Nouns" to explain why verbs (functions) matter over nouns (objects). - **Middle (~38%–47%)**: Demonstrates the critical difference between blocking and non-blocking operations with a live experiment—adding a 10-second `sleep` to one handler blocks all other requests. Explains why callbacks are essential for async operations and why the current synchronous return pattern breaks, setting up the fix: passing the response object through the stack so handlers can respond asynchronously. 【Key Takeaways】 - **Node.js is a server-side JavaScript runtime, not a browser tool** (Opening): Built on V8 but enhanced with file system, HTTP, and OS utilities, it lets you run JavaScript directly on your computer. This is the foundation for everything that follows. - **Use a version manager to install Node** (Opening): Instead of downloading binaries, tools like nvm let you switch between Node versions easily—useful for testing code across different releases and avoiding permission headaches. - **Node supports modern JavaScript (ES6+) out of the box** (Opening): Since you target one runtime (V8), you can write with the latest syntax without worrying about browser compatibility—a major advantage over frontend development. - **Modularity is key to scalable Node apps** (Early): Splitting code into `index.js` (entry point) and `server.js` (HTTP server module) keeps things readable. Using `require` and `exports` turns files into reusable modules, just like built-in ones. - **Callbacks are the heart of Node's async model** (Early): Functions can be passed as arguments and invoked later—this is how `http.createServer(onRequest)` works. Understanding this "function as a value" concept is essential before tackling real async code. - **Dependency injection enables loose coupling** (Middle): Passing a `handle` object (mapping URLs to handler functions) into the router—rather than hardcoding logic—makes the app extensible and mirrors how larger frameworks organize code. - **Blocking operations freeze everything** (Middle): A synchronous `sleep` in one handler delays all other requests, proving why non-blocking I/O matters. The fix involves passing the `response` object through the call stack so handlers can respond when async work completes. 【Reading Tips】 - **Skim the installation and npm sections** (Opening): If you already have Node installed, jump ahead—the key takeaway is just "use a version manager" and "check with `node -v`." - **Deep-read the callback and module explanations** (Early): The examples with `say()` and `execute()` are deceptively simple but crucial. Make sure you truly understand passing functions as arguments before moving on. - **Do the blocking experiment yourself** (Middle): The two-browser-window test with `/start` and `/upload` is the most valuable hands-on moment—it makes the async problem visceral and memorable. - **Watch for translation quirks**: Some code comments and variable names appear in Spanish (e.g., `exports.subir` for upload). Don't let this confuse you—focus on the structure, not the labels. - **Take away the architecture pattern, not just the code**: The server → router → handlers flow with dependency injection is a mini-framework you can reuse in real projects, even if you'd normally use Express. 【Coverage Limits】 Excerpts cover roughly the first half of the book (up to ~47%), focusing on setup, modules, callbacks, routing, and blocking vs. non-blocking. Later sections on actual file uploads, POST handling, and production deployment are not covered in this guide.