Build Your Own Web Server From Scratch In Node.JS (James Smith) (Z-Library)

【One-Line Pitch】 Learn by doing: build a complete, dependency-free web server in Node.js and TypeScript, mastering TCP, HTTP, and WebSocket fundamentals that apply to any language. Ideal for students, developers, and hobbyists who want to move beyond frameworks and truly understand the protocols powering the web. 【Book Arc】 - **Opening (~0%–9%)**: Introduces the "Build Your Own X" philosophy, explains why coding a web server from scratch deepens understanding, and outlines the book's structure—each chapter ends with discussions on real-world gaps, design choices, and alternative approaches. Sets expectations for a hands-on, language-agnostic journey. - **Early (~9%–25%)**: Covers HTTP basics by manually crafting requests with tools like netcat, socat, and curl, then dives into TCP server coding. Key insight: TCP is a byte stream, not a packet stream—a critical distinction that shapes all protocol design. Introduces the socket API (listen, accept, read, write) and the event loop's single-threaded nature. - **Early (~25%–34%)**: Explores asynchronous programming in depth: callbacks vs. Promises, async/await syntax, and converting callback-based APIs to promise-based ones. Discusses backpressure—why waiting for writes to complete prevents unbounded memory growth—and the importance of pausing data events for ordered execution. - **Middle (~34%–47%)**: Builds a simple message echo server with dynamic buffers, implementing a custom protocol with delimiters. Explains pipelined requests as a correctness test for parsers, showing how treating TCP data as a continuous stream (not packets) enables handling multiple messages in a single read. - **Middle (~47%–end)**: Moves to HTTP semantics and syntax, focusing on Content-Length and Transfer-Encoding as the core of message framing. Later chapters cover concurrent programming with blocking queues and a full WebSocket server implementation, tying together all prior concepts. 【Key Takeaways】 - **TCP is a byte stream, not a packet stream** (Early): The #1 beginner trap is "concatenating & splitting TCP packets"—they don't exist. Protocols must impose boundaries within the continuous byte flow, as DNS does with a 2-byte length prefix over TCP. - **The event loop is single-threaded and shared with your code** (Early): While a callback runs, the runtime can't handle other connections. Keep handlers short, yield voluntarily, or offload CPU-intensive work to threads/processes to avoid blocking everything. - **Backpressure prevents unbounded memory growth** (Middle): socket.write() always succeeds, even when the OS send buffer is full, pushing data into an unbounded internal queue. Waiting for write completion throttles production—look for unbounded queues as a sign of missing backpressure. - **Promises make async logic linear** (Early): Converting callback-based APIs to promises via an executor (resolve/reject) lets you write `await socket.read()` style code without breaking logic into scattered callbacks. Multiple connections then handle concurrently without explicit threading. - **Protocol parsers must be stateless regarding buffer size** (Middle): A correct parser consumes elements one by one, regardless of how much data arrives in a single read. Pipelined requests (multiple messages in one byte stream) are the ultimate test—if your parser treats reads as packets, it fails. - **Content-Length and Transfer-Encoding define HTTP message boundaries** (Middle): These headers are the most critical because they determine where a message ends in the byte stream. Understanding them is essential for any HTTP implementation, from servers to clients. - **Pause/resume data events for ordered execution** (Middle): Pausing the 'data' event isn't just for backpressure—it ensures events fire in a controlled sequence, preventing race conditions in callback-based code. 【Reading Tips】 - **Skim the discussion sections first** (end of each chapter): They explain "what's missing from the code" and "why it works that way"—the real value beyond the exercises. If short on time, read these before the code. - **Deep-read Chapter 3–4 (TCP server + Promises)**: These are the conceptual foundation. Master the event loop, backpressure, and promise conversion—everything later builds on these ideas. - **Code along with Chapter 5 (message protocol)**: The dynamic buffer and `cutMessage()` function are small but dense. Implement them yourself, then test with pipelined input (`echo -e 'asdf\n1234' | socat ...`) to verify your parser. - **Use the suggested tools (socat, curl, openssl)**: Don't skip the manual HTTP request exercises—they build intuition for what your server will later parse. Note that HTTPS requires TLS, so use `openssl s_client` instead of netcat. - **Treat the final WebSocket chapters as a capstone**: They combine concurrency (blocking queues) with protocol design. If you're short on time, skim the queue implementation and focus on the WebSocket handshake and framing. 【Coverage Limits】 This guide synthesizes excerpts covering roughly the first half of the book (through HTTP semantics) plus chapter titles for later sections. Detailed content on WebSocket implementation, concurrent programming specifics, and the final HTTP server assembly are not covered in depth here.