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
Why QA Breaks on AI Systems
Software QA assumes a specification, deterministic behaviour, and a system that changes only when you change it. AI features violate all three. This lesson covers what actually breaks, why test counts and pass rates stop meaning anything, and the shift from verifying correctness to characterising a distribution of behaviour.
Branches, Tags, and Merging in SVN
How SVN handles parallel work. Covers the trunk-branches-tags convention, cheap copies that make a branch nearly free, why branches and tags are the same mechanism, merge tracking with svn:mergeinfo, reintegrating a branch, and moving between SVN and Git with git svn.
The Core Subversion Workflow
The everyday SVN commands and the model behind them. Covers the update-edit-commit cycle, status codes and diffs, the copy-modify-merge approach to conflicts, locking for unmergeable binary files, useful properties like svn:ignore, and how to undo changes safely.
Subversion: The Centralized Version Control Model
How Subversion (SVN) works and why it still exists in a Git world. Covers the centralized model, the central repository and working copy, global revision numbers and atomic commits, and the real reasons teams keep SVN: large binaries, path-based access control, and a single source of truth.
Integration Engines and the Interoperability Career
The hub that makes healthcare data flow: how an integration engine like Mirth Connect routes, filters, and transforms messages between systems, how it compares to a general dataflow tool like Apache NiFi, the other standards you will meet, and the concrete skills to break into interoperability engineering.
FHIR: Resources and the REST API
The modern, web-native healthcare standard. How FHIR models clinical data as modular resources, links them with references, and exchanges them over a plain REST API using JSON. Includes a real Patient resource, the core interactions, profiles and US Core, and the R4 versus R5 reality.
Healthcare Interoperability and the HL7 v2 Standard
Why hospital systems cannot talk to each other by default, and the standard that fixes it. Covers the four levels of interoperability, the HL7 family, and the anatomy of an HL7 v2 message: segments, fields, and delimiters. The foundation for a career in healthcare integration.
Unity: physics and the fixed timestep
Why Unity runs physics on its own 50Hz clock instead of the frame rate, and what follows from that. Covers rigidbodies and colliders, moving things correctly with forces rather than the Transform, interpolation for smooth motion, tunneling and continuous collision detection, and where physics cost actually comes from.
Unity: prefabs, assets, and serialization
How a Unity object survives being saved to disk and loaded back exactly as configured. Covers what serialization actually accepts, why GUIDs in .meta files matter more than filenames, prefabs and variants with their override rules, ScriptableObjects as shared data, and the field that keeps reverting to zero.
Unity: the script lifecycle and execution order
When your Unity code actually runs. Covers the Awake, OnEnable, Start ordering guarantees, the split between Update, FixedUpdate, and LateUpdate, why deltaTime is mandatory, how coroutines fit the frame, and the allocation habits that turn a smooth game into a stuttering one.
Unity: the GameObject and component model
Unity is built on composition, not inheritance: a GameObject is an empty container, and everything it can do comes from components bolted onto it. Learn the Transform and scene graph, how components find each other, the active-versus-enabled trap, and why composition beats a deep class hierarchy for games.
CPython: the GIL and free-threading
Why CPython has a Global Interpreter Lock, what it does and does not protect, and how the three concurrency models differ. Then how PEP 703 free-threading removes the GIL using per-object locks and biased, deferred, and immortal reference counting, plus the tradeoffs that keep it opt-in.
CPython: reference counting and the cyclic GC
How CPython reclaims memory: immediate reference counting for the common case, plus a generational cyclic garbage collector that catches the reference cycles counting cannot. Covers what changes a refcount, generations and thresholds, the gc module, __del__ and weakref, and why a process's memory does not always shrink.
CPython: bytecode and the interpreter loop
What actually runs when you run Python: the compiler turns source into a code object of bytecode, and a single C evaluation loop executes it on a stack machine, one frame per call. Covers code objects, the dis module, the value stack, frames, and the adaptive specializing interpreter.
CPython: the object and data model
How Python values really work under the hood: every value is a heap object with a type and a reference count, names are references not boxes, and behavior comes from the data model's dunder methods. Covers identity versus equality, attribute lookup order, descriptors, and __slots__.
Dynamic analysis and debuggers
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.
Disassembly and decompilation
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).
Binary formats and what the loader does
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.
Linting from first principles
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 async ORM in production
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.
FastAPI dependency injection and the request lifecycle
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.
Advanced Python typing for backend
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 and asyncio
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.
Database Sharding and Replication
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.