paperAI

Tech Study Notes

Plain-language notes on things worth understanding properly — one topic at a time.

New here? Start with Request-Response and work down the Backend Engineering list — each note builds on the one before it. Tick sections off as you go to track your progress.

Backend Engineering

A lecture-style series — 16 notes, best read in order.

  1. Request-Response — full cost timeline, serialization, boundary detection
  2. Sync vs Async — event loop, epoll, io_uring, async commit risks
  3. Push Model — WebSocket push, fan-out, heartbeats, connection cleanup
  4. Short Polling — job-ID pattern, polling intervals, TTL strategies
  5. Long Polling — long vs short poll, Kafka use case, timeout handling
  6. Server-Sent Events — SSE wire format, Last-Event-ID, auto-reconnect
  7. Pub/Sub — delivery guarantees, RabbitMQ vs Kafka, idempotency, DLQ
  8. Multiplexing & Pooling — HTTP/2 streams, QUIC, connection pooling, PgBouncer
  9. Stateful vs Stateless — session vs JWT, the revocation problem, refresh tokens
  10. Sidecar Pattern — service mesh, Envoy, Istio, Dapr

Protocols — the layer everything above sits on.

  1. Protocol Properties — framing, addressing, flow control, stateful vs stateless
  2. The OSI Model — 7 layers, L4 vs L7 proxies, VPNs, CDNs
  3. UDP — connectionless transport, and when it is the right call
  4. TCP — reliable transport, handshakes, congestion control
  5. TLS — handshake, certificates, encryption in transit
  6. Internet Protocol — IP addressing, subnetting, TTL, ICMP

Database

SQL from the ground up — 14 notes, best read in order. Examples run against the DVD Rental sample database.

  1. SELECT — reading data out of a table, the most-used statement in SQL
  2. SELECT DISTINCT — stripping duplicates to get only the unique values
  3. COUNT — how many rows come back, and COUNT(*) vs COUNT(column)
  4. WHERE — syntax — filtering rows, the comparison operators, the gotchas
  5. WHERE — applied — building a query condition by condition, and the OR mistake everyone makes
  6. ORDER BY — sorting results, including by multiple columns
  7. LIMIT — capping rows, and ORDER BY + LIMIT as the "top N" pattern
  8. BETWEEN — inclusive ranges, and the timestamp trap that bites everyone
  9. IN — matching any item in a list, and the NOT IN + NULL trap
  10. LIKE & ILIKE — wildcard pattern matching and case sensitivity
  11. Aggregate Functions — many rows in, one value out, and why GROUP BY has to exist
  12. GROUP BY — theory — split/apply/combine, the golden rule, and execution order
  13. GROUP BY — applied — real queries on the payment table; read every one with the word "per"
  14. HAVING — filtering groups after aggregation, a WHERE for aggregate results

Going further — a book-length field guide for when the basics are done.

  • SQL in Practice — MySQL and PostgreSQL from first query to expert: joins, window functions, indexes, isolation, zero-downtime migrations, and a failure atlas of 14 real incidents

Interview Prep

Question-and-answer guides — 8 notes. Dip in by topic.

  • JavaScript — scope, closures, prototypes, async/await, the event loop, memory, ES6+
  • The JavaScript Interview Bible — engine internals through to production war stories, chapter by chapter
  • React — hooks, virtual DOM, Fiber, state, context, performance, Server Components, React 19
  • TypeScript — types, generics, utility types, decorators, conditional types, declaration merging
  • Angular — components, services, NgModules, router, RxJS, signals, standalone, @defer
  • Design Patterns — 10 core GoF patterns: singleton, factory, builder, adapter, decorator, proxy, observer and more
  • Data Structures & Algorithms — Big-O, arrays, trees, graphs, dynamic programming, sorting
  • System Design — scalability, CAP, caching, CQRS

Language Guides

Practical references — 3 notes.

  • Modern JavaScript (ES2024) — async/await, toSorted(), Object.groupBy(), Promise.withResolvers(), Set operations
  • Essential TypeScript — the daily-use subset: utility types, type guards, unknown, satisfies, Result<T,E>
  • TypeScript Q&A — fast reference: interface vs type, generics, narrowing, strict mode

Deep Dives

Long-form explanations — 2 notes.

  • React Fiber, Explained Simply — how React decides what to update, and why it matters for performance
  • React Fiber Internals — building a "smoosh mode" with Dan Abramov to explore the begin/complete/commit phases, double buffering, and the reconciler source

Cheatsheets

Grab-and-go reference — 1 note.

  • Docker — commands, logs, cleanup, common errors

Tools

Working with the tooling — 7 notes.