Programming lessons & courses
127 lessons · 29 learning paths · free, quiz-checked, no signup required
Compilers, concurrency, databases, reverse engineering, and the other load-bearing layers under everyday code. Each lesson explains what the machinery actually does (parsers, locks, B-trees, loaders) with worked examples and realistic code.
Learning paths
Performance Profiling: Finding the Bottleneck That Matters
Most optimisation effort goes into code that was never the problem, because intuition about where time goes is reliably wrong. This path builds the discipline instead: the arithmetic that caps what any optimisation can buy, how profilers work and how to read a flame graph, the six causes behind almost all real slowness, and how to benchmark honestly and recognise the point where optimising stops paying.
Deployment Strategies: Shipping Without Breaking Things
A deploy replaces a working system with a different one while people are using it. This path covers how teams make that routine: the four strategies as answers to how many users meet a bad version, canary releases as controlled experiments, feature flags separating deploy from release, and the compatibility discipline that decides whether the rollback you are counting on actually works.
The AWS Ecosystem: A Map of the Platform
AWS lists hundreds of services, which makes it look like a catalogue to memorise. It is not. This path gives you the scaffolding everything else hangs from: the geography of regions and availability zones, accounts and IAM as your blast radius, the compute spectrum from machines to functions, the three shapes of storage and how to choose a database, and the network layout that quietly decides your bill.
Testing Strategy: What Is Worth Testing
Tests are a purchase, not a virtue: you spend writing time, run time and maintenance time to buy confidence about specific breakages. This path works out how to spend that budget. What each level of test can and cannot catch, how test doubles buy speed by trading away fidelity, how property-based testing finds the inputs you would never have imagined, and why flakiness destroys a suite faster than any missing test.
Observability: Knowing Why Production Is Slow
Monitoring answers the questions you wrote down in advance; production fails in ways you did not. This path builds observability from its raw materials: the three telemetry signals and their very different bills, the percentile and cardinality arithmetic that decides what your data can honestly say, tracing and the craft of throwing spans away, and the SLO machinery that turns reliability into a number a team can actually spend.
Kubernetes: Orchestration as a Set of Control Loops
Kubernetes looks like a pile of object types until you notice it is one idea repeated. Store a description of the desired state, and run loops that compare it to reality and act on the difference. Because those loops read the current state rather than react to events, missed and duplicated messages are harmless and an interrupted controller simply resumes. This path builds the loop, shows every object as a controller joined by label matching, covers the two resource numbers that drive most cost and latency bugs, and ends with the failures the design itself creates.
Containers From First Principles
There is no container object in the Linux kernel and no container system call. A container is an ordinary process with several isolation features switched on, all of which predate the technology by years. So the thing that actually changed practice was not the kernel: it was an image format that is immutable, content-addressed and shippable, built on the same idea as Git's object store. This path covers the primitives, the format and its consequences, where data and traffic have to go, and the honest answer on how much the isolation is worth.
Git Internals: The Model Under the Commands
Git's command line has a deserved reputation, and the data model underneath is small and regular. It is a content-addressed store of four object types, plus a set of files holding hashes. This path derives the object hash by hand, shows that a branch is a forty-character file, explains what a three-way merge actually computes and why rebase creates new commits rather than moving them, and ends with recovery. Every command turns out to add objects or move a pointer.
Go: Goroutines, Channels, and What Was Left Out
A thread costs enough that programs are architected around not having many. A goroutine costs little enough that the constraint disappears, and the designs that become available are the point. This path builds the scheduler that makes them cheap, the channels that let them coordinate without shared memory, and the leak that is the characteristic Go bug because nothing stops a goroutine but its own return. It ends on the omissions: no exceptions, no inheritance, no formatting choices, and what each one trades.
Rust: Ownership, Borrowing, and What They Buy
Every language decides who frees memory and when, and Rust decides it at compile time from one rule: each value has exactly one owner. This path builds that rule, then the borrowing discipline that lets values be lent without transferring them. The payoff arrives in the third lesson, where data races turn out to be compile errors for free, because a race is aliasing plus mutation and the checker already forbids that. It ends on the escape hatches and where the guarantee genuinely stops.
No-Code Automation: Building Workflows That Keep Working
These platforms remove the cost of writing integration code, which was real, and leave the cost of operating an integration, which is larger and arrives later. This cursus covers why automations break once they run unattended, why partial failure is worse than total failure, and the idempotency problem behind most real damage. Then the patterns that survive production: validation, safe retries, rate limits, testing what you cannot test, and credentials. It ends on ownership, shadow automation, and when a flow has outgrown the tool.
Deploying Open-Source LLMs Privately
Self-hosting is usually justified on privacy grounds, and the argument is weaker than assumed: it changes who owns the controls, not whether controls are needed. This cursus examines the decision honestly, the reasons that hold up better than privacy, and the middle options the either-or framing hides. Then the serving stack: why generation is memory-bandwidth-bound, how continuous batching and KV cache management decide throughput, and sizing hardware. Then operating it, including the safety layer you inherited and must now rebuild.
Building an AI QA Function
Software QA assumes a specification, deterministic behaviour, and a system that changes only when you change it. An AI feature violates all three, and a provider updating a model shifts behaviour with no commit for your pipeline to catch. This cursus covers what replaces the old practice: characterising a distribution rather than asserting correctness, the evaluation set as the function's real asset, a release gate with thresholds set before results are seen, and how to stand the function up in ninety days without it quietly dying.
Subversion (SVN): The Centralized Version Control System
Git won, but Subversion never left, and plenty of long-lived, high-value codebases still run on it. Knowing SVN makes you useful where the code actually lives, and it sharpens your sense of what Git chose and why. This short cursus covers SVN on its own terms: the centralized model with its global revision numbers and atomic commits, the everyday update-edit-commit workflow with conflicts and locking, and branches, tags, and merging built from cheap directory copies, plus how to bridge to Git with git svn.
Healthcare Interoperability: HL7, FHIR, and Integration Engines
Clinical systems do not speak the same language by default, and someone has to make them. Healthcare interoperability is a durable, in-demand engineering niche with a low barrier to practice. This cursus builds it from the ground up: the interoperability problem and the HL7 v2 message model that still carries most hospital traffic, then FHIR's modern resource and REST API model, and finally the integration engine, Mirth Connect, that routes and transforms clinical data between systems, plus the concrete skills to break in.
How Unity works: the engine under your game
Stop fighting the engine and start using it. Learn why Unity is built on composition instead of class hierarchies, exactly when your code runs across Awake, Update, and the physics loop, how prefabs and serialization decide what survives to disk, and why physics runs on its own 50Hz clock. Finish able to explain the bugs that stump most Unity developers: the field that keeps resetting, the object that tunnels through walls, and the script that mysteriously never runs.
How Python really works: CPython internals
Go under the hood of the interpreter that runs most Python. Start with the object and data model, where every value is a heap object and behavior lives in dunder methods. See how source becomes bytecode and runs on a stack machine with an adaptive interpreter. Learn how reference counting and the cyclic collector reclaim memory. Finish with the GIL and the free-threading build that makes it optional. Come out able to reason about performance, memory, and concurrency from mechanism, not folklore.
Reverse engineering fundamentals
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.
Advanced Python for backend
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.
Scalable System Design
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.
How Compilers Work
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.
Distributed Systems Fundamentals
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.
Database Internals
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.
Concurrency and Parallel Programming
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.
Applied Modern Cryptography
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.
Full-Stack with Node.js, React, and Next.js
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.
Parallel Programming with CUDA
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.
API Design & Reliability
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.
Data Engineering Foundations
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.
All Programming lessons
Claude Code: Niche Features You're Probably Not Using
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.
Full-Stack Next.js with Prisma and Postgres
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.
Server vs Client Components in Next.js
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 App Router Fundamentals
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.
Data Fetching in React
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.
React Hooks: State and Effects
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.
React Components and JSX
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.
Building REST APIs with Express
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.
Node.js Runtime Fundamentals
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.
Profiling CUDA: Occupancy, Memory Coalescing, and Nsight
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.
Shared Memory Tiling for Matrix Multiplication
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.
Your First CUDA Kernel: Vector Addition End-to-End
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.
CUDA Memory Hierarchy: Global, Shared, Constant, Local, Registers
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.
CUDA Programming Model: Kernels, Threads, Blocks, and Grids
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.
Parallel Computing Fundamentals: CPUs, GPUs, Latency vs Throughput
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.
SQL JOINs: Combining Data from Multiple Tables
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.
PostgreSQL Indexes: Unlocking Query Performance with B-tree, Hash, GIN, and GiST
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.
OAuth 2.0: Deep Dive into Authorization Flows
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.
Crafting Robust APIs: Essential REST Design Principles
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.
Mastering Retrieval-Augmented Generation (RAG)
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.
Vector Databases and Similarity Search: Unlocking Semantic Understanding
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.
LangChain: Building Your First LLM Application
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).
Snowflake: Cloud Data Warehouse Fundamentals
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.
Apache Kafka: Distributed Event Streaming for Data-Intensive Applications
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.