Programming lessons & courses

How to read a compiled binary back into something a human can reason about. The file format and loader, disassembly and decompilation of x86-64, and dynamic analysis with debuggers and instrumentation. Three lessons of mechanism — what the toolchain on each side actually does, and what no amount of effort can recover.

The advanced syntax and runtime patterns that production Python backends rely on. Async and asyncio fundamentals, the type system as both static contract and runtime spec, FastAPI's dependency-injection model, and SQLAlchemy 2.0's async ORM — four lessons of mechanism over framework hagiography.

Design systems that handle millions of users without falling over. You will size and scale app tiers with load balancers and autoscaling, apply caching strategies that cut DB load by 95%, partition databases with sharding and replication, and wire services together with message queues and resilience patterns — leaving you ready to lead a real system design review.

Follow source code on its full journey from raw characters to machine instructions. You will build intuition for each compiler phase — scanning, parsing, semantic analysis, and code generation — and understand why each exists, what can go wrong inside it, and how the phases connect. By the end you will be able to read compiler error messages with precision, write a toy expression evaluator, and reason about what your compiler is doing when you flip on -O2.

After finishing this cursus you will be able to design, evaluate, and reason about distributed systems with engineering precision: model failures and time correctly, choose the right consistency level for a workload, explain why consensus is hard and how Raft solves it safely, and architect replication and partitioning strategies that scale without creating hot spots or correctness bugs.

Go beneath the SQL surface and understand how databases actually work. After this track you will be able to explain how data is laid out on disk, why B-trees dominate relational indexes, when to reach for an LSM-tree instead, and how MVCC lets Postgres serve thousands of concurrent readers and writers without blocking. You will read query plans, tune buffer pools and checkpoints, design indexes that avoid heap fetches, and reason precisely about isolation levels and concurrency anomalies.

Master the full concurrency stack: from race conditions and lost updates, through mutexes and deadlock prevention, to CPU memory models and lock-free atomics, and finally to async event loops and coroutines. After this cursus you can reason about any concurrent system, pick the right synchronization primitive, and debug races and deadlocks methodically.

Build the cryptographic judgment to evaluate any system's security posture. You will be able to choose the right primitive for each job (AES-GCM, HMAC, Argon2, ECDH, Ed25519), explain why common constructions fail (ECB, textbook RSA, nonce reuse, bare CTR), read a TLS 1.3 handshake trace, and audit real code for the most dangerous cryptographic misuses.

An eight-lesson path that builds a full-stack engineer from the runtime up. Start with the Node.js event loop, build a REST API with Express, learn React fundamentals and hooks, master modern data fetching, then move into Next.js App Router, Server Components, Server Actions, and a Prisma + Postgres deployment.

A six-lesson path from why GPUs exist to writing your own performant CUDA kernels. Learn the programming model, memory hierarchy, and optimization techniques that turn a 100x speedup from theoretical into practical.

Six lessons on shipping an HTTP API that other engineers actually enjoy using. Start with REST principles and status codes, secure it with OAuth 2.0, then make it survive real traffic with rate limiting, idempotency, and load balancing.

An eight-lesson path from SQL fundamentals to a modern data stack. You'll learn how to query and tune relational data, cache hot reads, model with dbt, choose between lakehouse and warehouse architectures, and wire pipelines together with Kafka and Airflow. By the end you can reason about every layer a production data platform actually runs on.

Reverse engineering by running the binary. Why dynamic analysis sees what static cannot, how debuggers and breakpoints actually work (INT3 vs hardware vs page-fault), tracing (strace, ltrace, dtrace, eBPF), dynamic binary instrumentation with Frida and PIN, the common anti-debug tricks, sandboxing with Unicorn and Qiling, and the static-dynamic loop that does the real work.

Reading machine code back into something a human can reason about. Instruction decoding (linear sweep vs recursive descent), x86-64 calling conventions, stack frames, control-flow graph recovery, what decompilers actually do and what they fundamentally cannot recover, and the practical tool landscape (IDA, Ghidra, Binary Ninja, radare2).

The first layer of reverse engineering — the file format on disk and the loader that maps it into memory. ELF, PE, and Mach-O as variants of the same idea; sections vs segments; symbol tables and what stripping actually removes; PLT/GOT/IAT and dynamic linking; packers like UPX; and the triage you do before opening a disassembler.

What a linter actually is, what its rules enforce, how AST-based analysis works, the cost of auto-fix, the ecosystem (ESLint, Ruff, Clippy, golangci-lint), where to wire it in (LSP / pre-commit / CI), why false-positive rate is the real budget, and when a custom rule pays for itself.

SQLAlchemy 2.0 from the production angle. The engine/session/transaction layering, the typed declarative, the identity map, the N+1 query problem, async-only gotchas (no lazy loading), savepoint nesting, and the connection-pool knobs that decide whether the backend survives load.

Dependency injection as a pattern, FastAPI's Depends as one concrete implementation. Sub-dependencies and per-request caching, yield-based cleanup, where Pydantic v2 validation runs, lifespan-scoped resources, BackgroundTasks vs real queues, and the override trick that makes the whole thing testable.

Python's type system has two audiences — static checkers and runtime frameworks. Generics, Protocol, TypedDict, ParamSpec, type narrowing, and runtime introspection, framed as the spec that Pydantic, FastAPI, and SQLAlchemy actually execute.

Async Python from the bytecode up. Coroutines vs return values, how the event loop schedules tasks, when async beats threading or multiprocessing, structured concurrency with TaskGroup, and the cancellation rules that production backends live or die by.

Go beyond a single database: learn how read replicas offload query load, how range and hash sharding partition data, why consistent hashing makes rebalancing tractable, and how to pick a shard key that avoids the celebrity problem and cross-shard pain.

Master the mechanics of scaling distributed systems: when to scale up versus out, why statelessness is the prerequisite for horizontal scale, how L4 and L7 load balancers differ, which balancing algorithm fits which workload, and how to avoid turning your load balancer into the next single point of failure.

Learn how message queues and pub/sub decouple services, why at-least-once delivery demands idempotent consumers, how backpressure and dead-letter queues protect the system, and when microservices are worth the complexity — with a sequenceDiagram of async order processing.

Understand where caches live, how cache-aside, read-through, write-through, and write-back differ, how to choose eviction policies, and how to prevent cache stampedes — with hit ratio math and a concrete cache-aside code snippet.

How do you scale a database beyond one machine while keeping it reliable? This lesson covers every major replication topology, the quorum math behind leaderless systems, and partitioning strategies from range keys to consistent hashing — including how to avoid hot partitions and handle rebalancing.

Distributed systems break in ways single machines don't: nodes crash silently, messages vanish, and clocks lie. Learn the standard failure taxonomy, why a global clock is physically impossible, and how Lamport and vector clocks let you reason about causality without one.

Consensus is the hardest fundamental problem in distributed systems — and the one everything else depends on. Understand why FLP makes it theoretically impossible in async systems, how quorums work, and exactly how Raft solves leader election, log replication, and commitment safely.

CAP is the most misquoted theorem in distributed systems. Get the precise statement, learn why PACELC is more useful in practice, and master the consistency spectrum from linearizability down to eventual consistency — with concrete trade-offs for each level.

Transactions are a promise. Learn the ACID guarantees, the exact anomalies each SQL isolation level prevents or allows, why two-phase locking blocks and MVCC does not, and how Postgres uses row versions plus a transaction ID visibility check to give you snapshot isolation without holding a single read lock.

Disk geometry dictates database design. Learn why sequential I/O beats random I/O by 100x, how fixed-size pages and slotted page headers work, why row-stores and column-stores suit different workloads, how the buffer pool keeps hot pages in RAM, and how the write-ahead log makes durability cheap.

B-trees rule read-heavy OLTP; LSM-trees rule write-heavy workloads. Learn how the memtable and immutable SSTable pipeline converts random writes into sequential I/O, why compaction is unavoidable, how bloom filters slash unnecessary reads, and when to pick LSM over B-tree.

B+ trees are the workhorse of relational databases. Learn why their high fanout and shallow depth match disk perfectly, how point lookups and range scans work, the difference between clustered and secondary indexes, how covering indexes eliminate table lookups, and the hidden write cost of keeping indexes up to date.

AES and block ciphers are primitive building blocks, not complete encryption schemes. Learn how ECB leaks structure, why CBC and CTR modes work differently, and why GCM is the modern default — including the catastrophic consequences of nonce reuse.

Trapdoor functions power every TLS handshake, code signature, and SSH session. Master RSA key generation and its math, why textbook RSA is trivially broken, what elliptic curves add, and how ECDSA and Ed25519 compare — with key-size equivalences you can quote in code reviews.

Every HTTPS connection negotiates a fresh secret over an untrusted network. Learn Diffie-Hellman and ECDH from first principles, why forward secrecy matters when private keys leak, how TLS 1.3 cut the handshake to one round-trip, and how certificate chains stop man-in-the-middle attacks.

Hash functions are not all equal and MACs are not just hashes with a secret. Learn the three resistance properties, why length-extension attacks break naive HMAC constructions, how KDFs differ from hashes, and why bcrypt/scrypt/Argon2 exist for passwords.

Threads look deceptively simple — create a few, share some memory, done. In practice, shared mutable state is a minefield: race conditions, non-deterministic output, and bugs that vanish under a debugger. This lesson dissects concurrency vs parallelism, why `count++` is three operations the CPU can interleave, Amdahl's law, and what a critical section actually means.

The CPU and compiler silently reorder your code. Cache coherence does not mean coherent behavior. This lesson explains the happens-before relation, memory fences, C++ and Java atomic operations, compare-and-swap, and why `volatile` is not a synchronization primitive.

Mutexes, condition variables, semaphores, and reader-writer locks — the primitives that make concurrent code correct. Understand the four Coffman deadlock conditions, how lock ordering prevents them, and why contention turns a performance win into a bottleneck.

Threads are not the only model for concurrency. Learn how blocking vs non-blocking I/O works, how the event loop and reactor pattern scale to millions of connections, and how callbacks evolved into futures, promises, and async/await — plus where coroutines fit and when async loses to threads.

The parser only checks syntax — it happily accepts `x = y + z` even if none of those names exist. Semantic analysis adds meaning: it builds symbol tables, resolves names, enforces scoping rules, and runs the type checker that catches the errors a grammar cannot. Learn what happens between the raw AST and the typed AST the IR generator gets.

The parser takes a flat token stream and recovers the hierarchical structure the programmer intended. Learn context-free grammars, recursive-descent parsing, operator precedence, the difference between a parse tree and an AST, and when LL versus LR parsers matter — including the classic dangling-else ambiguity.

Before a compiler can understand your code it has to chop it into meaningful pieces. Learn how scanners work, how regular expressions become finite automata, why maximal munch is the rule, and what a real token stream looks like — the foundation every later compiler phase depends on.

The typed AST is high-level — too high for a CPU. Learn why compilers lower to an intermediate representation first, what SSA form buys you, how classic optimizations (constant folding, dead-code elimination, CSE) transform IR, and how instruction selection and register allocation finally produce machine code.

You already let Copilot autocomplete your code. This lesson dives into the underused power features: chat participants, slash commands, Copilot Edits, agent mode, custom instructions, prompt files, the model picker, MCP servers, and Copilot Spaces.

A tour of the underused Claude Code power features beyond basic prompting: CLAUDE.md memory, plan mode, rewind, custom slash commands, subagents, hooks, MCP servers, statusline, and headless mode.

Ship a full-stack app on Next.js 15: Prisma schema, migrations vs db push, the hot-reload-safe client singleton, Server Components reading data, Server Actions mutating it, useOptimistic, Auth.js, and a Vercel + Neon deploy.

The RSC mental model: server-by-default, the 'use client' boundary, what can cross it, Server Actions with 'use server', streaming with Suspense, and a Postgres-to-Client end-to-end example.

Next.js 15 App Router: page/layout/loading/error files, nested layouts, dynamic and catch-all segments, route groups, parallel routes, and the Metadata API for SEO — with the file tree as a diagram.

From hand-rolled useEffect fetches to TanStack Query v5 and SWR: race conditions, caching, mutations, optimistic updates, error boundaries, and when to push fetching to the server.

useState, useEffect, useReducer, and useContext in React 19: the rules, snapshot semantics, dependency arrays, when NOT to useEffect, and the dependency-array footgun that bites everyone.

Master React 19's core primitive: function components, JSX, props, children, composition, conditional rendering, and stable keys — built around a small TODO list you can ship.

Build a small REST API on Node 22 with Express: routes, middleware, JSON body parsing, Zod input validation, status codes, and a clean async error pipeline you won't outgrow.

How Node 22 actually runs your code: V8, the libuv event loop and its phases, microtasks vs macrotasks, blocking pitfalls, and where worker threads, npm, pnpm, and bun fit in 2026.

A working CUDA kernel is the start, not the finish. How to measure occupancy, spot uncoalesced loads and warp divergence, and read the three numbers in Nsight Compute that actually matter.

Why naive matmul on a GPU is bandwidth-starved, and how tiling with __shared__ memory reduces global memory traffic by a factor of the tile size. The classic optimisation, with the kernel that demonstrates it.

The hello-world of CUDA, done properly. Allocate device memory, copy inputs, launch a kernel, copy results back, free, and check every return code. The full driver + kernel in one runnable file.

The five memory spaces a CUDA kernel can see and why they have wildly different speeds. Global vs shared vs constant vs local vs registers, coalesced access, bank conflicts, and a cheat-sheet table you'll actually reference.

How CUDA carves a problem into a grid of blocks of threads. Host vs device code, the __global__ qualifier, the launch syntax, and how every thread figures out which slice of data it owns.

Why GPUs eat CPUs for breakfast on some workloads and choke on others. Serial vs parallel execution, Amdahl's law, the latency-vs-throughput trade-off baked into silicon, and a rule of thumb for when to reach for a GPU.

Learn how to combine data from different tables in a relational database using the four fundamental SQL JOIN types: INNER, LEFT, RIGHT, and FULL OUTER. We'll explore what each join does, when to use it, and how they differ, using clear examples and diagrams.

Dive deep into the world of PostgreSQL indexes. Understand the core mechanics of B-tree, Hash, GIN, and GiST indexes, their optimal use cases, and how to choose the right indexing strategy to dramatically accelerate your database queries.

Explore the core concepts of OAuth 2.0, its various grant types, and how it enables secure, delegated access without sharing credentials. Understand the roles and the step-by-step authorization process.

Learn the foundational principles behind RESTful API design. This lesson covers statelessness, client-server architecture, uniform interface, effective use of HTTP methods and status codes, and practical tips for building scalable and maintainable web services.

Explore Retrieval-Augmented Generation (RAG), a powerful technique that enhances Large Language Models (LLMs) by grounding their responses in external, up-to-date, and domain-specific information, mitigating hallucinations and improving factual accuracy. This lesson covers its core components, workflow, and practical considerations.

Dive into the world of vector databases, specialized systems designed to store and query high-dimensional vector embeddings efficiently. Learn how these databases power semantic search, recommendation systems, and large language model applications by finding semantically similar data points at scale.

A beginner's guide to LangChain, the popular framework for composing applications with Large Language Models. Learn the core concepts of Models, Prompts, and Chains, and build a simple application using the LangChain Expression Language (LCEL).

Learn the foundational concepts of Snowflake, the cloud-native data platform. Explore its unique architecture, key features like time travel and zero-copy cloning, and understand how its pricing model works.

Dive into Apache Kafka, a powerful distributed streaming platform designed for high-throughput, fault-tolerant data pipelines. Understand its core components, architecture, and how it enables real-time data processing for modern applications.

Dive into Apache Airflow, the powerful platform for programmatically authoring, scheduling, and monitoring complex data workflows. Learn about DAGs, operators, and how to build robust, scalable pipelines for modern data engineering.

Learn the fundamentals of dbt (data build tool), the industry standard for transforming data directly within your cloud data warehouse. This lesson covers core concepts like models, materializations, sources, and testing, empowering you to build reliable and modular data pipelines with just SQL.

Explore the data lakehouse, a modern architecture that merges the cost-efficiency and flexibility of data lakes with the performance and reliability of data warehouses. This lesson covers its core components, benefits, and the open-source technologies that make it possible.

HTTP status codes are essential for effective communication between clients and servers on the web. This lesson breaks down each class of status codes (1xx, 2xx, 3xx, 4xx, 5xx), explains their meaning, and provides practical guidance on when to use them in your applications.

Dive into LangSmith, the developer platform for building and evaluating robust Large Language Model (LLM) applications. Learn how to trace execution paths, debug complex chains, and rigorously evaluate your LLM's performance to ensure reliability and quality.

Explore Redis, a powerful open-source in-memory data store. Learn its core concepts, why it's used, its versatile data structures, and how it delivers blazing-fast performance for caching, real-time analytics, and more.

A beginner-friendly tour of Big-O: what it measures, the common growth classes, and how to spot them in your own code.