📚 สารบัญทั้งหมด — โครงสร้างหนังสือ

← กลับหน้าแรก · สารบัญรายบทของทั้ง 26 หมวด พร้อมป้ายระดับความยาก

🔰 เพิ่งเริ่มอ่าน? ข้ามไปอ่านส่วนแนะนำก่อนได้: หนังสือนี้ออกแบบมาให้ใคร · วิธีอ่านที่แนะนำ · คำศัพท์พื้นฐาน

🚦 ป้ายระดับความยาก — ดูก่อนเลือกบท เพื่อไม่ให้เดินชนกำแพง:

• พื้นฐาน — เริ่มจากศูนย์ได้ ไม่ต้องมีพื้นฐานมาก่อน
• ระดับกลาง — ควรเขียนโปรแกรมเป็นแล้ว หรือผ่านหมวดพื้นฐานที่เกี่ยวข้องมาก่อน
• ระดับสูง — สำหรับคนทำงานแล้ว หรือเตรียมขึ้น senior — มือใหม่ ข้ามไปก่อนได้ ค่อยกลับมาเมื่อพร้อม

บางหมวดไต่ระดับขึ้นเรื่อย ๆ ภายในเล่มเดียว — บทท้าย ๆ ที่เป็น ระดับสูง จะมีหมายเหตุกำกับไว้ในวงเล็บ

🗣️ English Grammar · พื้นฐาน → สูง

หมวดพิเศษ (ไม่ใช่ programming): ไวยากรณ์อังกฤษสำหรับคนไทยเริ่มจากศูนย์ — สอนเป็นภาษาไทย ตัวอย่างอังกฤษพร้อมแปล เน้นจุดที่คนไทยผิดบ่อย + ใช้จริงในแต่ละสถานการณ์

→ เข้าหมวด English Grammar

📚 บททั้งหมด

ภาค A (แกนไวยากรณ์): 00 ภาษาอังกฤษทำงานยังไง · 01 Nouns/Articles · 02 Pronouns · 03 to be · 04 Present · 05 Past · 06 Future · 07 Perfect · 08 Modals · 09 Questions · 10 Adjectives/Adverbs · 11 Prepositions · 12 Sentence Building · 13 Conditionals · 14 Passive/Reported · 15 Advanced ภาค B (ตามสถานการณ์): 16 แนะนำตัว/Small talk · 17 กิน เที่ยว ช้อป เดินทาง · 18 ที่ทำงาน/อีเมล/สัมภาษณ์ ภาคผนวก & เล่มคู่: 19 ออกเสียง+ลิงก์เสียง · 20 ตาราง Reference (กริยา 3 ช่อง/เวลา/วันที่) · 21 Workbook+เฉลย · 22 Vocabulary ตามสถานการณ์ · 23 Phrasal Verbs 100

📒 JavaScript · พื้นฐาน

ภาษาของเว็บ — เป็นพื้นฐานก่อนเข้า React, Angular, Node.js, AI/LLM tooling

→ เข้าหมวด JavaScript

📚 บททั้งหมด (14 บท)

1. 00 — JS คืออะไร
2. 01 — Setup + Hello
3. 02 — Variables + Types
4. 03 — Operators + Expressions
5. 04 — Control Flow
6. 05 — Functions Deep (closure, this, arrow)
7. 06 — Objects + Prototypes + Class
8. 07 — Arrays + Iteration (map/filter/reduce)
9. 08 — Strings + Regex + Date
10. 09 — Async Deep (event loop, Promise, async/await)
11. 10 — Modules (ESM + CommonJS)
12. 11 — Error Handling
13. 12 — DOM + Events
14. 13 — Modern JS + Tools

📘 TypeScript · พื้นฐาน

JavaScript ที่ใส่ type — เขียน frontend/backend แบบทีมใหญ่ได้ (ควรผ่าน JavaScript ก่อน)

→ เข้าหมวด TypeScript

📚 บททั้งหมด (12 บท)

1. 00 — TS คืออะไร
2. 01 — Setup + tsconfig
3. 02 — Basic Types
4. 03 — Functions + Overload
5. 04 — Object Types + Interface
6. 05 — Generics Deep
7. 06 — Utility Types
8. 07 — Type Narrowing
9. 08 — Class + Modifier
10. 09 — Module + Declaration
11. 10 — Advanced Patterns (mapped, template literal, branded)
12. 11 — TS in Practice (React, Node, migration)

🟩 Node.js · พื้นฐาน → สูง

JavaScript ฝั่ง server — ตัวรันโค้ด (runtime), ตัวจัดการแพ็กเกจ (npm), core modules, เว็บเซิร์ฟเวอร์ ถึง REST API จริงระดับใช้งานจริง (production) · ชั้นที่หายไประหว่าง JavaScript กับ NestJS (ควรผ่าน JavaScript บท 9–10 ก่อน · บท 10–11 เป็น ระดับสูง)

→ เข้าหมวด Node.js

📚 บททั้งหมด (12 บท)

1. 00 — Node.js คืออะไร + Setup (runtime, event loop, nvm, REPL)
2. 01 — Modules + npm (CJS vs ESM, package.json, semver, lockfile)
3. 02 — Core Modules + process (globals, env, argv, path, os)
4. 03 — Async + Events (callback→Promise, EventEmitter, event loop, AbortController)
5. 04 — Filesystem + Streams (fs, Buffer, backpressure, pipeline)
6. 05 — HTTP + Web Server (จาก http เปล่า → Express, middleware)
7. 06 — Error Handling + Debugging (uncaught/unhandled, --inspect)
8. 07 — Config, CLI + Lifecycle (env, 12-factor, graceful shutdown)
9. 08 — Testing (node:test, mock, supertest, Vitest)
10. 09 — Database + REST API จริง (pg, connection pool, validation)
11. 10 — Performance + Scaling (worker_threads, cluster, profiling)
12. 11 — Production + Modern Node (Docker, health, logging, roadmap → NestJS)

🐳 Docker · พื้นฐาน

Container ตั้งแต่มือใหม่ — namespace, image, network, volume, compose, security

→ เข้าหมวด Docker

📚 บททั้งหมด (6 บท)

1. 00 — Container คืออะไร + Architecture
2. 01 — Image เจาะลึก (layer, Dockerfile, multi-stage)
3. 02 — Networking (bridge, port mapping, DNS)
4. 03 — Volumes (เก็บข้อมูลไม่ให้หาย)
5. 04 — Docker Compose
6. 05 — Security + Optimization (rootless, sign, scan)

☸️ Kubernetes · ระดับกลาง

จัดการ container ข้ามหลายเครื่อง — pod, deployment, service, helm, production (ควรผ่าน Docker ก่อน)

→ เข้าหมวด Kubernetes

📚 บททั้งหมด (11 บท)

1. 00 — K8s คืออะไร + Architecture
2. 01 — Pod (หน่วยเล็กที่สุด)
3. 02 — Deployment + ReplicaSet (self-healing, rolling update)
4. 03 — Service + Networking
5. 04 — ConfigMap + Secret
6. 05 — Storage (PV/PVC)
7. 06 — Ingress
8. 07 — Health Check + Autoscaling
9. 08 — StatefulSet + DaemonSet + Job
10. 09 — Helm + Deployment Strategy
11. 10 — Observability + Production

📘 Java · พื้นฐาน

ภาษาที่เป็นรากฐานของ Spring Boot — ต้องแข็งก่อนถึงไปต่อได้ (บท 16–19 เป็น ระดับสูง ข้ามไปก่อนได้)

→ เข้าหมวด Java

📚 บททั้งหมด (20 บท)

1. 00 — บทนำ: Java คืออะไร ทำไมต้องเรียน
2. 01 — ติดตั้ง + Hello World แบบเข้าใจทุกบรรทัด
3. 02 — ตัวแปร, ประเภทข้อมูล, operator
4. 03 — Control flow (if, switch, loop)
5. 04 — Method และ scope
6. 05 — OOP พื้นฐาน (class, object, encapsulation)
7. 06 — Inheritance, polymorphism, interface, abstract (แบ่ง 3 ตอน): 06a Inheritance · 06b Polymorphism · 06c Interface
8. 07 — Collections + Generics (List, Map, Set)
9. 08 — Exception handling
10. 09 — Lambda, Stream, Optional (functional style)
11. 10 — Modern Java (records, sealed, pattern matching, virtual threads)
12. 11 — Date/Time + I/O + Files (java.time, Path/Files, JSON)
13. 12 — Concurrency (Thread, synchronized, volatile, virtual threads)
14. 13 — Networking + Regex + Cryptography (HttpClient, BCrypt, AES)
15. 14 — Annotations + Modules + Build Tools (Maven, Gradle, Javadoc)
16. 15 — Testing + Logging (JUnit 5, AssertJ, Mockito, SLF4J)
17. 16 — JVM Internals + Memory + GC (bytecode, G1/ZGC, JMM, JIT)
18. 17 — JDBC + Connection Pool (PreparedStatement, HikariCP tuning)
19. 18 — Reflection + Annotation Processing (dynamic proxy, mini DI/ORM)
20. 19 — Performance + Profiling (JFR, async-profiler, JMH, GC tuning)

🌱 Spring Boot · ระดับกลาง

Framework ที่ทำให้เขียน backend Java เร็วและไม่ปวดหัว (บท 10–15 เป็น ระดับสูง)

→ เข้าหมวด Spring Boot

📚 บททั้งหมด (16 บท)

1. 00 — Spring คืออะไร และทำไมต้องมี IoC/DI
2. 01 — REST API แรก: อธิบายทุก annotation
3. 02 — Database + Spring Data JPA
4. 03 — Security + JWT
5. 04 — Testing (unit + integration)
6. 05 — Production Readiness (Docker, Actuator, Logging)
7. 06 — AOP + Bean Scope (Aspect, Pointcut, scopes, @Conditional)
8. 07 — OAuth2 (Login with Google, Resource Server, OIDC)
9. 08 — Microservices + Spring Cloud (Eureka, Gateway, OpenFeign, Circuit Breaker)
10. 09 — Spring MVC ลึก (Servlet, Filter, Interceptor, ControllerAdvice)
11. 10 — Reactive (WebFlux + R2DBC, Mono/Flux, backpressure)
12. 11 — Caching (Spring Cache, Caffeine, Redis, patterns)
13. 12 — Messaging (Kafka + RabbitMQ, Outbox, Saga, DLQ)
14. 13 — Batch + Scheduling (@Scheduled, ShedLock, Spring Batch)
15. 14 — GraphQL (schema-first, DataLoader, Subscriptions)
16. 15 — Native Image (GraalVM AOT, RuntimeHints, FaaS)

🟦 C# · พื้นฐาน

ภาษา OOP + functional ที่ Microsoft สร้าง — รากของ .NET ทุก stack

→ เข้าหมวด C#

📚 บททั้งหมด (13 บท)

1. 00 — C# + .NET คืออะไร
2. 01 — Setup + Hello World
3. 02 — Variables + Types (value vs reference, NRT, nullable)
4. 03 — Control Flow (switch expression + pattern matching)
5. 04 — Methods + Scope (ref/out/in, params, local function)
6. 05 — OOP Fundamentals (class, property, primary ctor)
7. 06 — Inheritance + Polymorphism (interface, abstract, sealed)
8. 07 — Collections + Generics
9. 08 — Exception Handling
10. 09 — Lambda + Delegate + LINQ
11. 10 — Modern C# (record, pattern, NRT, collection expression)
12. 11 — Async + Tasks + Cancellation
13. 12 — IO + Files + JSON + HttpClient

🟦 .NET (ASP.NET Core) · ระดับกลาง

Framework backend ของ .NET — REST/GraphQL/gRPC/microservice บน Kestrel (ควรผ่าน C# ก่อน)

→ เข้าหมวด .NET

📚 บททั้งหมด (9 บท)

1. 00 — ASP.NET Core คืออะไร (pipeline, DI, host)
2. 01 — REST API แรก (Minimal + Controller)
3. 02 — Database + EF Core (code-first, migration, transaction)
4. 03 — Security + JWT (Identity, Policy-based)
5. 04 — Testing (xUnit + WebApplicationFactory + Testcontainers)
6. 05 — Production Readiness (Serilog, OTel, Docker, AOT)
7. 06 — Middleware + Pipeline ลึก
8. 07 — Dependency Injection ลึก (lifetime, options, Polly)
9. 08 — Background Service + Channels + Quartz + Hangfire

🐹 Go · พื้นฐาน

ภาษาที่ Google ออกแบบ — compile เร็ว, deploy เป็น binary เดียว, concurrency ง่าย (Kubernetes/Docker/Terraform ใช้) (บท 13–15 เป็น ต่อยอด)

→ เข้าหมวด Go

📚 บททั้งหมด (16 บท)

1. 00 — Go คืออะไร + Setup
2. 01 — Variables + Types
3. 02 — Control Flow (for, if, switch, defer)
4. 03 — Functions (multiple return, closure, variadic)
5. 04 — Collections (array, slice, map)
6. 05 — Structs + Methods (composition over inheritance)
7. 06 — Interfaces (implicit implementation)
8. 07 — Errors (errors.Is/As, wrapping, panic vs error)
9. 08 — Concurrency (goroutine, channel, select, context)
10. 09 — Packages + Modules (go.mod)
11. 10 — Testing (table-driven, benchmark, fuzz)
12. 11 — Standard Library (net/http, encoding/json, log/slog)
13. 12 — Modern Go (generics, slog, embed, iter, context, DI)
14. 12b — Production Playbook (shutdown, container, observability, profiling, security)
15. 13 — Web Framework Deep
16. 14 — Database in Go (database/sql, pgx, sqlc, GORM)
17. 15 — gRPC + Protobuf

⚛️ React · ระดับกลาง

Library frontend ที่ทำให้ UI เป็น component ที่ reuse ได้ (บท 13–16 เป็น ระดับสูง)

→ เข้าหมวด React

📚 บททั้งหมด (17 บท)

1. 00 — React คืออะไร + ทบทวน JS/TS
2. 01 — React app แรก: component, JSX, props, state
3. 02 — Hooks เชิงลึก (useEffect, useMemo, useRef, useContext, custom hook)
4. 03 — Form + Validation (React Hook Form + Zod)
5. 04 — Data Fetching (TanStack Query)
6. 05 — Routing (React Router)
7. 06 — Styling + UI Libraries (Tailwind, shadcn/ui, Radix, MUI)
8. 07 — State Management (Zustand, Jotai, Redux Toolkit)
9. 08 — Testing (Vitest, React Testing Library, MSW, Playwright)
10. 09 — Advanced Patterns (HOC, Portal, ErrorBoundary, Suspense, Compound)
11. 10 — Animation + Performance (Motion, virtualization, Web Vitals)
12. 11 — Next.js (App Router, Server Components, Server Actions)
13. 12 — React Native (Expo, mobile app intro)
14. 13 — TypeScript Deep for React (satisfies, discriminated union, polymorphic)
15. 14 — React Internals (Fiber, reconciliation, React 19 Compiler, RSC)
16. 15 — Accessibility + i18n + SEO (WCAG, ARIA, react-i18next, Web Vitals)
17. 16 — Authentication + Authorization (Auth.js, Clerk, OAuth, JWT, protected route + RBAC)

🪺 NestJS · ระดับกลาง

Backend framework สำหรับ TypeScript ที่มี DI, decorator, lifecycle pipeline — เหมือน Spring Boot ของฝั่ง Node (ควรผ่าน TypeScript ก่อน)

→ เข้าหมวด NestJS

📚 บททั้งหมด (9 บท)

1. 00 — NestJS คืออะไร (IoC, DI, decorator)
2. 01 — Modules + Providers (รากของ DI container)
3. 02 — Controllers + Routing (REST API)
4. 03 — Middleware, Pipes, Guards, Interceptors, Filters
5. 04 — Database (TypeORM + Prisma)
6. 05 — Authentication + JWT (Passport, RBAC, refresh token)
7. 06 — Testing (unit + integration + e2e)
8. 07 — Microservices + GraphQL (TCP/Kafka/gRPC, code-first)
9. 08 — Production Readiness (logging, config, health, deploy)

🅰️ Angular · ระดับกลาง

Framework frontend แบบ "batteries included" — นิยมใน enterprise / banking / government (บท 10–11 เป็น ระดับสูง)

→ เข้าหมวด Angular

📚 บททั้งหมด (12 บท)

1. 00 — Angular คืออะไร + Setup
2. 01 — Components + Templates
3. 02 — Signals + State (Angular 17+)
4. 03 — Services + DI
5. 04 — Routing (guards, lazy load, resolver)
6. 05 — Forms (Template + Reactive)
7. 06 — HTTP + RxJS (operators, interceptor)
8. 07 — Change Detection + Performance (zoneless, OnPush)
9. 08 — Testing (Jasmine, TestBed, e2e)
10. 09 — SSR + Modern Angular (hydration, deferrable views)
11. 10 — NgRx + Signal Store (state management)
12. 11 — Micro-frontends

🚀 Microservices · ระดับสูง

Service decomposition, API gateway, message broker (RabbitMQ + Kafka เข้ม ๆ), saga, service mesh, deployment

→ เข้าหมวด Microservices

📚 บททั้งหมด (20 บท)

1. 00 — Microservices Mindset
2. 01 — Service Decomposition (DDD, bounded context)
3. 02 — Inter-Service Communication Overview
4. 03 — REST + gRPC Between Services
5. 04 — API Gateway + BFF Pattern
6. 05 — Service Discovery + Configuration
7. 06 — Message Broker Fundamentals
8. 07 — RabbitMQ เข้ม
9. 08 — Apache Kafka เข้ม
10. 09 — Brokers อื่น ๆ (Redis Streams, NATS, Pulsar, SQS/SNS, Pub/Sub)
11. 10 — Broker Comparison + Choosing
12. 11 — Stream Processing (Kafka Streams, Flink)
13. 12 — Event-Driven Patterns (Saga, Outbox, Inbox, CDC/Debezium)
14. 13 — Resilience (Circuit Breaker, Bulkhead, Backpressure)
15. 14 — Data Management (DB per service, CQRS, Event Sourcing)
16. 15 — Distributed Tracing + Correlation
17. 16 — Security (mTLS, Zero Trust, JWT propagation)
18. 17 — Service Mesh (Istio, Linkerd, Envoy)
19. 18 — Deployment (Canary, Blue-Green, GitOps)
20. 19 — Polyglot Example End-to-End

🤖 AI / LLM · ระดับกลาง

LLM, prompt engineering, RAG, embeddings, agents, evaluation, production AI stack

→ เข้าหมวด AI / LLM

📚 บททั้งหมด (6 บท)

1. 00 — LLM คืออะไร ทำงานยังไง (token, context window, temperature)
2. 01 — Prompt Engineering (zero/few-shot, CoT, structured output)
3. 02 — RAG + Embeddings (vector DB, chunking, hybrid search)
4. 03 — Function Calling + Agents (tool calling, ReAct, security)
5. 04 — Evaluation + Production (golden dataset, cost, latency, resilience)
6. 05 — Modern AI Stack (LangChain, local models, fine-tuning vs RAG)

🧠 Claude · พื้นฐาน → ระดับสูง

ใช้งาน Claude ครบ 3 ช่องทาง (เว็บ · Claude Code · API) + prompt engineering + สร้าง AI agent

→ เข้าหมวด Claude

📚 บททั้งหมด (8 บท)

1. 00 — Claude คืออะไร + เลือกช่องทาง
2. 01 — ตระกูลโมเดล + การเลือกใช้ (Opus/Sonnet/Haiku)
3. 02 — เริ่มต้นกับ claude.ai (Projects, Artifacts, ฟีเจอร์เว็บ)
4. 03 — ศิลปะการเขียน Prompt (few-shot, CoT, XML)
5. 04 — Claude Code (CLAUDE.md, Skills, Hooks, MCP, subagents)
6. 05 — Claude API (Messages API, tool use, caching, vision)
7. 06 — AI Agents (agent loop, subagents, Agent SDK)
8. 07 — ข้อจำกัด ความปลอดภัย คำศัพท์ + Roadmap

🌐 Distributed Systems · ระดับสูง

ทฤษฎีระบบกระจาย — CAP (ทฤษฎีบทว่าด้วยความสอดคล้องของข้อมูล), consensus (การตกลงค่าร่วมกัน), replication (การทำสำเนาข้อมูล), time/ordering, event-driven, แพตเทิร์นสมัยใหม่ (CRDT — โครงสร้างข้อมูลที่ผสานกันได้เอง ฯลฯ)

→ เข้าหมวด Distributed Systems

🏗️ System Design · ระดับสูง

Scalability, data layer, communication, reliability, worked examples (Twitter, Uber, ฯลฯ), interview strategy

→ เข้าหมวด System Design

🧭 แผนที่นำทาง 3 เล่มสถาปัตยกรรมขั้นสูง — Microservices, Distributed Systems, System Design มีหัวข้อทับกันบ้าง (event-driven, consistency, resilience) นี่คือวิธีเลือกว่า "เรื่องนี้อ่านเล่มไหน":

คุณอยากได้อะไร	อ่านเล่มนี้ก่อน
ทฤษฎีรากฐาน — ทำไมระบบกระจายถึงยาก (CAP, consensus, time/ordering, replication)	Distributed Systems — เน้น "why" เชิงทฤษฎี
ลงมือสร้างระบบหลายเซอร์วิส — แยกเซอร์วิส (decompose), ตัวรับส่งข้อความ (broker), saga (จัดการธุรกรรมข้ามเซอร์วิส), service mesh, deploy	Microservices — เน้น "how" เชิงปฏิบัติ มีโค้ด/แพตเทิร์น
ออกแบบระบบในภาพใหญ่ + เตรียมสัมภาษณ์ — scalability, worked examples (Twitter/Uber), trade-off	System Design — เน้น "what trade-off" ระดับภาพรวม

ลำดับที่แนะนำ: Distributed Systems (เข้าใจทฤษฎี) → Microservices (ลงมือ) → System Design (มองภาพใหญ่ + สัมภาษณ์) · หัวข้อที่ทับกัน แต่ละเล่มมองคนละมุม — อ่านซ้ำได้ ไม่เสียเปล่า

🔗 Full-stack · ระดับกลาง

เอา 3 เล่มข้างบนมาเชื่อมต่อกัน — ทำ React + Spring Boot เป็น app เดียวที่ deploy ขึ้นจริงได้ (ควรผ่าน React + Spring Boot ก่อน)

→ เข้าหมวด Full-stack

📚 บททั้งหมด (6 บท)

1. 00 — ภาพรวม Full-Stack (architecture, request flow)
2. 01 — เชื่อม React กับ Spring Boot (CORS, Vite proxy, API layer)
3. 02 — Auth Flow End-to-End (login → JWT → protected route, auto refresh)
4. 03 — CRUD + Optimistic UI (full task manager example)
5. 04 — File Upload (avatar, multi-file, progress, S3 presigned)
6. 05 — Deployment (Docker, Nginx, Compose, HTTPS, CI/CD)

🗄️ Database · พื้นฐาน

SQL ลึก, schema design, indexing, transactions, NoSQL — เสริมจาก Spring Boot บทที่ 02

→ เข้าหมวด Database

📚 บททั้งหมด (9 บท)

1. 00 — Database คืออะไร (SQL vs NoSQL, RDBMS landscape)
2. 01 — SQL พื้นฐาน (DDL + DML, types, constraints)
3. 02 — JOIN + Relationships (1-1, 1-N, M-N, FK)
4. 03 — Aggregation + Subquery + Window Function
5. 04 — Indexing + Performance (B-tree, EXPLAIN, N+1)
6. 05 — Transaction + ACID + Isolation Level + MVCC
7. 06 — Schema Design + Normalization
8. 07 — PostgreSQL Features ลึก (JSONB, FTS, Partition)
9. 08 — NoSQL Intro (MongoDB, Redis)

🌐 API Design · ระดับกลาง

ออกแบบ REST/GraphQL/gRPC API ที่ดี — เสริมจาก Spring Boot บทที่ 01

→ เข้าหมวด API Design

📚 บททั้งหมด (7 บท)

1. 00 — API คืออะไร (REST/GraphQL/gRPC overview)
2. 01 — REST Design ลึก (resource, method, status, HATEOAS)
3. 02 — Pagination, Filter, Sort, Search
4. 03 — Versioning + Error Handling (Problem Details RFC 7807)
5. 04 — Auth + Security + Rate Limit (OWASP API Top 10)
6. 05 — OpenAPI + Documentation (Springdoc, Contract-first)
7. 06 — GraphQL + gRPC

🧠 Programming Concepts · ระดับกลาง

OOP ลึก, SOLID, Design Patterns, Clean Code, FP, Architecture — ใช้ได้ทุกภาษา

→ เข้าหมวด Programming Concepts

📚 บททั้งหมด (7 บท)

1. 00 — Mindset ก่อนเขียน Code
2. 01 — OOP ลึก (composition over inheritance)
3. 02 — SOLID Principles
4. 03 — Design Patterns (Strategy, Factory, Observer, ...)
5. 04 — Clean Code (naming, function, comment, error)
6. 05 — Functional Programming (pure, immutable, map/filter/reduce)
7. 06 — Architecture Patterns (Layered, Hexagonal, DDD, Modular Monolith)

⚙️ DevOps · ระดับกลาง

Linux, Git, Docker, Kubernetes, CI/CD, Cloud, Observability

→ เข้าหมวด DevOps

📚 บททั้งหมด (10 บท)

1. 00 — DevOps คืออะไร (CALMS, DORA, SRE)
2. 01 — Linux + Shell (filesystem, permission, scripting)
3. 02 — Git + GitHub Workflow
4. 03 — Docker ลึก (image, container, network, compose)
5. 04 — Kubernetes Intro (pod, deployment, service, ingress)
6. 05 — CI/CD (GitHub Actions, deployment strategies)
7. 06 — Cloud Platforms + IaC (AWS/GCP/Azure, Terraform)
8. 07 — Monitoring + Observability (Prometheus, Grafana, Loki, Tempo)
9. 08 — Nginx ลึก (reverse proxy, load balance, TLS, caching)
10. 09 — Traefik ลึก (cloud-native edge router, ACME, k8s)

🔒 Security · ระดับกลาง

Threat model, OWASP, auth, crypto, secrets, supply chain, hardening — เสริมจาก Spring Boot บทที่ 03

→ เข้าหมวด Security

📚 บททั้งหมด (8 บท)

1. 00 — Security Mindset (CIA, STRIDE, defense in depth)
2. 01 — OWASP Top 10 (injection, XSS, CSRF, SSRF, BOLA)
3. 02 — Authentication ลึก (BCrypt/Argon2, MFA, JWT, Passkeys)
4. 03 — Authorization (RBAC, ABAC, ReBAC, OPA, multi-tenant)
5. 04 — Cryptography for Devs (hash, HMAC, AES-GCM, TLS, KMS)
6. 05 — Secret Management (Vault, KMS, rotation, incident response)
7. 06 — Supply Chain Security (SBOM, signing, dependency scan)
8. 07 — Hardening + Monitoring (SIEM, incident response, postmortem)

🔭 Observability · ระดับสูง

Logging, Metrics, Tracing, Dashboard, Alerting, SLO ลึก — ต่อยอด DevOps บทที่ 07

→ เข้าหมวด Observability

📚 บททั้งหมด (10 บท)

1. 00 — Observability Mindset (3 pillars, OTel, golden signals)
2. 01 — Logging ลึก (structured, MDC, LogQL, retention)
3. 02 — Metrics + Prometheus ลึก (PromQL, cardinality, RED/USE)
4. 03 — Distributed Tracing (OpenTelemetry, sampling, debugging)
5. 04 — Dashboard Design (golden signals, Grafana, anti-patterns)
6. 05 — Alerting + On-Call (symptom-based, runbook, fatigue)
7. 06 — SLI/SLO/Error Budget (burn rate, multi-window alerts)
8. 07 — Incident Management + Postmortem (blameless, 5 Whys)
9. 08 — Loki + LogQL (architecture, cardinality, retention)
10. 09 — Elasticsearch สำหรับ Log (ILM, mapping, hot-warm-cold)

---

เกี่ยวกับหนังสือเล่มนี้

ทำไมต้องมี branch นี้

ไฟล์เดิมที่ programming/ กับ backend/ มี ข้อมูลครบ แต่เขียนแบบ เอกสารอ้างอิง (reference):

• ใช้ตารางเยอะ → อ่านเร็วถ้ารู้แล้ว แต่ "ทำไม" หาย
• bullet สั้น → ข้ามขั้นตอนความเข้าใจ
• สมมติว่าผู้อ่านรู้ศัพท์ → มือใหม่งง
• โค้ดตัวอย่างไม่มี comment อธิบายทีละบรรทัด

Branch นี้แก้ปัญหานั้น — เล่าเรื่อง, อธิบายทุกบรรทัดของโค้ด, ถามคำถามชวนคิด, มี checkpoint ลงมือทำ

ถ้าคุณอ่านจบแล้วยัง ไปต่อยอดเองได้ ถือว่าหนังสือนี้ทำงานสำเร็จ

หนังสือนี้ออกแบบมาให้ใคร

คุณคือใคร	ควรอ่านยังไง
ไม่เคยเขียนโปรแกรมเลย	เริ่ม JavaScript บทที่ 0 → อ่านเรียงทุกบท → ทำ checkpoint ทุกอัน
เคยเขียนภาษาอื่น (Python/JS) มา	ข้าม Java บทที่ 0 ได้ → เริ่มบทที่ 1 → อ่านไว ๆ ถึงบทที่ 4 → อ่านละเอียดจาก OOP ขึ้นไป
เคยเขียน Java แต่จะขึ้น Spring	ข้าม Java ทั้งเล่ม → เริ่ม Spring Boot บทที่ 0
เคยทำ backend จะขึ้น React	ข้ามไป React บทที่ 0

สไตล์การเขียนของหนังสือนี้

1. อธิบาย "ทำไม" ก่อน "อะไร" — ไม่ใช่แค่บอกว่าใช้ syntax อะไร แต่เล่าว่าทำไมมันถึงเป็นแบบนั้น

2. โค้ดทุกตัวอย่างมี comment อธิบายทีละบรรทัด

// public  = method นี้เรียกจาก class อื่นได้ (จาก outside)
// static  = ไม่ต้องสร้าง object ของ class นี้ก็เรียกได้ (เพราะ JVM ไม่รู้จะสร้างยังไง)
// void    = method นี้ไม่ return ค่ากลับมา (โปรแกรมแค่ทำงานแล้วจบ)
// main    = ชื่อที่ JVM ตกลงจะหา ห้ามใช้ชื่ออื่น
// String[] args = arguments ที่ส่งมาตอน run โปรแกรมจาก command line
public static void main(String[] args) {
    // System.out = object ที่ชี้ไปที่ stdout (จอภาพ/terminal)
    // println    = print + line break ตอนท้าย
    System.out.println("Hello, World!");
}

3. มี "Checkpoint" ทุกบทให้ลงมือทำ — บางหมวดแทรกระหว่างหัวข้อ (เช่น Java, Go, Angular), บางหมวดเป็น Lab + Checkpoint ท้ายบท (เช่น JavaScript, Docker, Kubernetes) — หลักการเดียวกัน: อ่านอย่างเดียวลืมเร็ว ต้องลงมือทำ

4. มี "Common Pitfalls" — กับดักที่คนใหม่ตกบ่อย พร้อมอธิบายว่าทำไมถึงผิด

5. มี "เปรียบเทียบกับชีวิตจริง" — เช่นอธิบาย OOP ด้วยรถยนต์ (Class = แบบพิมพ์เขียว, Object = รถคันที่ผลิตจริง, Field = สี/เครื่อง, Method = ขับ/เบรก/เลี้ยว)

วิธีอ่านที่แนะนำ

1. อย่ารีบ — บทแรก ๆ ที่เป็นพื้นฐาน ถ้าข้ามจะเจ็บภายหลัง
2. ลงมือทำ Checkpoint ทุกอัน — อ่านอย่างเดียวลืมเร็ว
3. เปิด terminal + IDE ไว้ตลอด — เห็นโค้ดต้องลอง type ทันที (อย่า copy-paste — type เอง สมองจำได้ดีกว่า)
4. มี notebook (กระดาษ/Notion/Obsidian) จดสรุปด้วยภาษาตัวเอง — เขียนซ้ำในภาษาตัวเอง = เข้าใจจริง
5. ถ้าไม่เข้าใจอ่านซ้ำ — ถ้ายังไม่เข้าใจ ลอง search keyword ที่งง — แล้วค่อยกลับมาอ่านต่อ

คำศัพท์พื้นฐานที่ทุกบทจะใช้

ไม่ต้องท่อง แต่ให้รู้ว่าเจอตรงนี้คือหมายความว่าอะไร — เจอบ่อยจะจำเอง

💡 นี่คือศัพท์ที่ "เจอทุกบท" เท่านั้น — ศัพท์เทคนิคเฉพาะทางอื่น ๆ (เช่น decorator, closure, middleware, container, pod, RAG, token ฯลฯ) ทั้งคลังมีคำอธิบายอยู่แล้ว: เอาเมาส์ชี้คำที่ขีดเส้นใต้ในเนื้อหาบทใด ๆ จะมีคำอธิบายสั้น ๆ เด้งขึ้นมา (tooltip)

คำ	ความหมาย
Source code	โค้ดที่เราเขียน (.java, .js, .tsx ฯลฯ)
Compile	แปลโค้ดที่เราเขียน → format ที่เครื่อง/runtime run ได้
Runtime	สภาพแวดล้อมตอนโปรแกรม run อยู่ (เช่น JVM, Node.js, browser)
IDE	Integrated Development Environment — โปรแกรมที่ใช้เขียนโค้ด (IntelliJ, VS Code)
Terminal / Shell	หน้าจอที่พิมพ์คำสั่งให้คอมทำ (PowerShell, bash, zsh)
CLI	Command Line Interface — โปรแกรมที่ใช้ผ่าน terminal
Build tool	โปรแกรมที่จัดการ compile + download library + package โปรแกรม (Maven, Gradle, npm)
Dependency / Library / Package	โค้ดของคนอื่นที่เราเอามาใช้
Framework	ชุดเครื่องมือ + กฎการใช้ ที่บังคับโครงสร้างแอป (Spring Boot, React)
API	Application Programming Interface — "หน้าบ้าน" ที่ให้คนอื่นเรียกใช้
REST	สไตล์การออกแบบ API ผ่าน HTTP — เดี๋ยวจะอธิบายละเอียดตอน Spring
JSON	format ข้อมูลที่ทุกภาษาอ่านได้ — { "key": "value" }

License และการใช้

เขียนสำหรับใช้ส่วนตัว — เผยแพร่ได้ภายในทีม แต่กรุณาให้เครดิต