Systems Programming for Trading

AdvancedPremium4 sections · 19 lessons · 38 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 four 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 last part is the round almost nobody practises, where you are handed broken code and given an hour.

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. The C++ problems light up as the judge that compiles them rolls out, so a quiet lesson is a problem set on its way, not a gap; a few lessons drill their concepts through Python problems that are live today.

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 preview Ownership, 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.

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.

Keep reading Systems Programming for Trading

19 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