Programming lessons &amp; courses

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.

8 lessons · certificate

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.

6 lessons · certificate

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.

6 lessons · certificate

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.

8 lessons · certificate

All Programming lessons

The Runtime Stack, and What Isolation Is Worth

One command hides four layers of software and a set of standards that made them interchangeable. This lesson takes the stack apart, then asks the question the whole path has been building toward: given a shared kernel, how much is container isolation actually worth, and what has to be added before it is a security boundary.

Networking and Storage: Connecting an Isolated Thing

Isolation is the point, and a container that can reach nothing and keep nothing is useless. This lesson covers how a network namespace is wired to the outside, why published ports and container-to-container traffic work completely differently, and where data has to live given that the writable layer disappears.

Images: A Filesystem You Can Address by Hash

The kernel gives isolation for files already on the machine. The image format is what turned a directory tree into something you can build once, name by digest and run anywhere. This lesson covers layers and the union filesystem that stacks them, why the build cache behaves as it does, and the content addressing that makes it all work.

A Container Is Not a Thing

There is no container object in the Linux kernel, no container system call, and no container data structure. A container is an ordinary process started with several isolation features switched on at once. This lesson establishes what those features are, what the word actually names, and why the distinction changes how you reason about them.

Undo: Reset, Revert, Restore, and Getting Work Back

Git's undo commands are notoriously confusing because they are usually memorised as recipes. Read against the object model they separate cleanly: each acts on a different one of the three places content lives. This lesson maps them, covers recovery from the accidents that feel unrecoverable, and states what genuinely cannot be undone.

Merge and Rebase: Two Answers to Divergence

Every operation so far moved a pointer. Merging is the first that has to decide something: two branches changed the same project and one result must come out. This lesson covers the three-way merge and the merge base it depends on, what a conflict actually is, and why rebase produces different commits rather than moving them.

Refs: A Branch Is a File Containing a Hash

Hashes are unusable by hand, so Git names them. A branch is not a copy of anything, not a directory, and not a container for commits: it is a forty-character file. Once that is clear, checkout, reset, detached HEAD and the reflog stop being separate concepts and become one operation on one kind of file.

The Object Database: Git Is a Content-Addressed Store

Git is usually taught as a set of commands. Underneath it is a key-value store where the key is a hash of the content, and four object types built on that one idea. This lesson derives the hash by hand, shows what a commit actually contains, and explains why the design makes history tamper-evident.

The Design Philosophy: What Go Left Out

Go is unusual for what it refuses to include. Errors are values, not exceptions. Interfaces are satisfied without declaring it. Formatting is not a choice. This lesson works through the omissions, the reasoning behind each, and the real costs, because every one of them trades expressiveness for something else.

Goroutine Leaks: Who Stops This Thing

Starting a goroutine is one keyword; stopping one is a design decision nothing forces you to make. A goroutine blocked forever is never collected and holds everything it references, which is the most common Go-specific bug. This lesson covers how leaks happen, the cancellation mechanism that prevents them, and how to detect the ones already there.

Channels: Share Memory by Communicating

Cheap concurrency without a coordination primitive is a bug generator. Go's answer is a typed conduit that carries values between goroutines, from a 1978 idea: rather than protecting shared state with locks, pass ownership through a channel so there is no sharing to protect. This lesson builds channels, select, and where the model does not fit.

Goroutines: Concurrency Cheap Enough to Stop Counting

A thread costs enough that programs are architected around not having many. A goroutine costs little enough that the constraint disappears, which changes what designs are available. This lesson explains where the saving comes from, what the runtime scheduler does with them, and what the abundance does not fix.

Unsafe, and Where the Guarantee Actually Ends

The borrow checker rejects some correct programs, so Rust provides ways out: runtime-checked cells, reference counting, and unsafe blocks. This lesson covers what each escape hatch turns off, what it does not, and the encapsulation discipline that keeps a small unsafe core from voiding the guarantee for everything above it.

Fearless Concurrency: The Same Rule, Applied Across Threads

Rust did not add a concurrency safety mechanism. A data race requires aliasing plus mutation, which the borrow checker already forbids, so data races became compile errors as a side effect. This lesson shows how two marker traits extend that guarantee across threads, and what it still does not prevent.

Borrowing: Aliasing XOR Mutation

Moving a value to read it is unusable, so ownership needs a way to lend. The lending rule is one line, and it is the reason Rust can guarantee no dangling references: you may have many readers or one writer, never both. This lesson builds that rule and the lifetimes that enforce it across function boundaries.

Ownership: One Rule That Replaces the Garbage Collector

Every language must decide who frees memory and when. Rust answers with a rule enforced at compile time: each value has exactly one owner, and it is freed when that owner goes out of scope. This lesson builds the rule, shows what moving a value means, and explains what the approach buys and charges.

When It Outgrows the Tool, and Who Owns It Meanwhile

Automations become infrastructure without anyone deciding they should. This lesson covers shadow automation and why banning it fails, documenting a flow so it survives its author, the signals that a workflow has outgrown no-code, and how to migrate without a rewrite.

Building Flows That Survive Contact With Reality

The concrete patterns that separate an automation that works from one that keeps working: validating input at the boundary, retrying only what is safe to retry, handling rate limits and batches, testing something you cannot easily test, and keeping secrets out of the flow.

Why Automations Break, and What That Costs

No-code automation makes building easy and running reliably hard. This lesson covers what these platforms actually are, the failure modes that appear once something runs unattended, why partial failure is worse than total failure, and the idempotency problem behind most real damage.

Operating It: Security, Upgrades, and Knowing When to Stop

Self-hosting is a permanent operational responsibility rather than a project. This lesson covers the security surface a local model creates, model upgrades and why they are harder than they look, capacity and cost control, what to monitor, and the honest signals that the deployment should be retired.

The Serving Stack: Throughput, Memory, and Hardware Sizing

A model that runs is not a model that serves. This lesson covers what an inference server does that a naive loop cannot, continuous batching and why it dominates throughput, the memory arithmetic that decides which hardware you need, quantization for serving, and how to size a deployment from a traffic estimate.

The Case for Self-Hosting, Examined Honestly

Self-hosting is usually justified on privacy grounds, and the argument is often weaker than assumed. This lesson examines what actually stays private, which regulatory requirements genuinely demand it, the reasons that hold up better than privacy, and the honest total cost against an API.

Standing Up the Function: First Ninety Days and Beyond

An AI QA function has to be built while features are already shipping. This lesson covers the order of work that produces something useful fast, where the function should sit, how to handle a team that resists a new gate, what to measure about the function itself, and the failure modes that quietly end it.