Courses

Systems Programming for Trading

AdvancedPremium6 sections · 27 lessons · 68 questionsLog in to track progress

Most top trading firms run their trading systems in C++, and they do not interview on it the way a general technology company does. The algorithm round is table stakes. What separates the offers is a set of questions a generic platform never asks: what does virtual cost, what exactly does std::move do to the object you moved from, why is this counter wrong without a mutex and still wrong with a relaxed atomic, and here is a working program, find the leak.

That material is under-served for a simple reason. It is hard to auto-grade, so LeetCode and HackerRank do not carry it, so nobody drills it, so the firms that do ask it get a very clean signal. One major assessment bans Python outright. Another is C++ or nothing. A third opens with ten multiple-choice questions on language semantics before you write a line. Candidates have been asked to decide whether an address is on the stack or the heap, and then to explain the memory layout that makes the answer possible.

This course is that material, in six parts. C++ internals covers where objects live, who owns them, and what the language does behind each construct you type. Concurrency from scratch builds the primitives rather than calling them: condition variables, atomics, a lock-free queue for one writer, a thread pool. Compile-time programming covers the template work that the C++-first firms all probe. The fourth part is the round almost nobody practises, where you are handed broken code and given an hour. The fifth covers the systems round: the cache hierarchy, the network path to a feed handler, and measuring latency honestly. The sixth is the design round, both on one machine and across many.

It assumes you can already write correct C++ and read a header without flinching. If you want the algorithmic and Python side of the same pipeline, that is Programming for Quantitative Developers.

The practice links at the end of these lessons drill the same material in our coding catalogue. Every one of them is a C++ problem, compiled and run on the server-side judge, and each card shows the difficulty and the time to budget before you open it.

What the Machine Does With Your ObjectObject layout, padding and alignment, where a value actually lives, and why a trading firm asks you to tell the stack from the heap.Free previewOwnership, RAII and the Rule of FiveWho frees this, and when? The one question C++ makes you answer explicitly, and the five functions that answer it.Move Semantics Without the Folklorestd::move moves nothing. What the moved-from object is afterwards, the four situations where your move quietly becomes a copy, and the return statement that pessimises.Virtual Dispatch and What It CostsThe vtable, the indirect call, and the cost that is not the indirect call. Three ways to get polymorphism without it, and when the cost is worth paying.Allocators and Where Memory Comes FromWhat new actually calls, why the general allocator is too slow for a hot path, and the three special-purpose allocators worth being able to write.Type Erasure and the Cost of a CallableWhat std::function stores, why it sometimes allocates, and the same machinery inside shared_ptr. A reported C++ interview question, answered properly.Virtual Memory and the Kernel BoundaryWhat actually happens when you touch an address: page tables and the TLB, the faults that make first runs slow, and why hot paths avoid the kernel.Container Costs and Iterator InvalidationWhat each standard container costs once memory is involved, which operations leave your iterators and pointers dangling, and the erase loop that crashes.Floating Point and Undefined BehaviourWhat a double can and cannot hold, the comparisons NaN breaks, and why the compiler is allowed to delete your overflow check.What Changed From C++11 to C++20The features from each standard that trading code actually uses, the ones that cost nothing at runtime, and four new ways to refer to the wrong object.
Threads, Races and What Undefined Really MeansA data race is not a timing bug, it is a licence for the compiler to do anything. Why the counter that works is still wrong, and how to find one.Mutexes, Condition Variables and the Lost WakeupProducer-consumer built properly: why the predicate goes in a loop, where the lost wakeup actually hides, and how deadlock is avoided by ordering.Atomics and the Memory ModelSix memory orderings, three you will use, and the release-acquire pair that publishes data safely. Why relaxed is right for a counter and wrong for a flag.Lock-Free Queues: Start With One WriterThe SPSC ring is the one lock-free structure you can write correctly under interview pressure. What makes it work, and what changes when a second writer appears.Thread Pools and Work QueuesThe reported thread pool question, built properly: submission, shutdown that does not hang, and why the queue is usually the bottleneck.False Sharing and the Cache LineTwo threads, two variables, no shared data, and a tenfold slowdown. The coherence protocol behind it and the three fixes.Waiting Well: Spinning, Blocking and BackpressureWhat a context switch costs, why a hot path spins, and the question every queue eventually asks: what do you do when the consumer cannot keep up?
Templates as a LanguageInstantiation, overload resolution and SFINAE, and the modern replacements that make the same thing readable. What the C++-first firms are actually probing.Type Lists and Recursion at Compile TimeA published compile-time exercise, generalised: a list of types is a functional data structure, and the operations on it are the ones you already know.constexpr and Moving Work to the BuildTables computed by the compiler, strings hashed before the program starts, and the difference between code that can run at compile time and code that must.
How to Read Code You Did Not WriteOne reported senior assessment is seven fix-the-code problems in an hour. A procedure for finding a defect in unfamiliar code without reading all of it.The Fix-the-Bug RoundThree broken programs of the kind these firms set, worked through: a leaking container, a lost wakeup, and a race that only appears under load.
The Cache Hierarchy and What a Miss CostsHow big each cache level is, how long a miss takes, the three reasons a line is not there, and the layout changes that make the same algorithm several times faster.The Network Path to a Feed HandlerWhy orders go over TCP and market data over UDP multicast, how a feed handler recovers what UDP loses, and where the kernel drops packets without telling you.Measuring Latency Without Fooling YourselfHardware counters first, a sampling profiler second, latency as a distribution, and the benchmark mistakes that make a slow system look fast.
Designing a Low-Latency System on One MachineThe single-machine design round: put numbers on the load, give every stage one thread and one queue, keep blocking work off the hot path, and never let a slow reader stall the rest.Distributed Systems for the Design RoundThe other design round: machines that fail, messages that arrive twice, replication and its trade-offs, idempotent retries, ordering without trusted clocks, and why clusters have five nodes.

Keep reading Systems Programming for Trading

27 lessons in this course, and every other premium course, on one subscription.

Subscribe now
  • Every lesson in every course, with the worked examples and interactive simulators
  • Graded questions on every lesson, with explanations for the wrong answers as well as the right one
  • The trainers, timed assessments and brainteaser library that go with them