technology
17 curated learning paths about technology. Each path delivers daily 5-minute drops to build real knowledge over time.
💻Elixir Pattern Matching
Stop reading `=` as assignment and start using it as Elixir's core flow-control tool — through function heads, guards, and `with` — until you can rewrite a tiny command parser without a single `if`.
🐳Docker Containers Basics
Build the mental model first, then the commands — from containers vs VMs through images, layers, volumes, and networking to composing a multi-service app.
🧪Property-Based Testing
Go beyond example-based tests — learn to express what your code should always do, then let a framework find the inputs that break it.
🦀Rust's Ownership Model
Build a working mental model of Rust's ownership system — from stack vs heap intuition through borrow checker mastery — so you can read and write Rust without fighting the compiler.
🔷TypeScript Type Narrowing
Replace unsafe `as` casts with control-flow narrowing, discriminated unions, and type predicates — then build a type-safe API client that narrows responses by status code.
λMaster Haskell Typeclasses: From Functor to Monad
Climb the typeclass ladder one rung at a time - Eq, Show, Functor, Applicative, Monad - until real Haskell stops looking like runes, and you can ship a tiny expression DSL built on your own custom class.
🧵Understand Concurrency Memory Models and Write Race-Free Code
Stop guessing whether your atomics need `seq_cst` and start picking orderings from first principles — one primitive at a time — until you can write a lock-free counter that provably can't race.
🔗Master SQL Joins and Query Relational Data with Confidence
See joins as set operations first, then write every join type against a real schema, tune them with indexes and query plans, and finish by solving ten realistic reporting queries.
🔌REST API Design Principles
Design REST APIs that teams can actually use — resources, verbs, versioning, and pagination, grounded in the conventions senior engineers argue about on PR threads.
💻Go Error Handling Idioms
Stop writing `if err != nil` on autopilot. Learn why Go treats errors as values, then wrap, sentinel, and type them until you can design a clean error story for a small CLI.
💻The Actor Model
Stop reasoning about locks and start reasoning about mailboxes — across 14 drops you'll build a tiny actor runtime, wire up supervision, and finish by modeling a real workflow as an actor graph.
🌊Node.js Streams Introduction
Stop loading whole files into memory. Learn each Node.js stream type through runnable snippets and finish by building a streaming CSV-to-JSON transformer with proper backpressure and error handling.
🔭Observability: The Three Pillars
Build the mental model that turns three noisy data sources — metrics, logs, and traces — into a single evidence trail, then design an observability plan for a real service.
💎Ruby Blocks, Procs, and Lambdas
Untangle Ruby's three callable forms one at a time — blocks, procs, and lambdas — until you can convert between them, predict every return-and-arity gotcha, and end by building a small block-taking DSL of your own.
🔒JavaScript Closures Demystified
Build one mental model for closures that covers the setTimeout loop bug, private state, and React hooks — then ship a tiny state container using nothing but functions and lexical scope.
⚛️React Hooks Mental Model
Build one mental model for React hooks — each render is a snapshot, and every hook either reads from it or syncs the outside world to it — then use that model to fix stale closures, tame dependency arrays, and extract clean custom hooks from a real component.
🔁The JavaScript Event Loop
Draw the JavaScript event loop on a whiteboard from memory, then predict the output of any mixed sync/async code — and instrument a real program to prove you're right.