Quant Developer — Competency Roadmap

You'll learn

• Toolchain — the compiler, linker, and assembler pipeline that translates source code into machine code
• CMake — cross-platform build automation tool used to manage compilation dependencies
• WSL2 — Windows Subsystem for Linux providing an authentic Linux kernel environment on Windows machines

How to work through it

1. 1Install Clang 16+, GCC 13+, CMake, Ninja, and GDB via package manager
2. 2Configure a project folder with a standard layout (src, include, tests)
3. 3Write a CMakeLists.txt that specifies C++20 standard and pedantic warnings (-Wall -Wextra -Wpedantic)
4. 4Compile and run the binary using CMake in Release and Debug modes

You'll learn

• Stack vs Heap — the difference between automatic fast call-frame storage and dynamic heap allocation
• Pointers & References — direct memory addressing mechanisms in C++
• Alignment & Padding — compiler-inserted gaps ensuring variables sit on hardware-friendly memory boundaries

How to work through it

1. 1Study primitive types, fixed-width integers (cstdint), and IEEE 754 floating-point representations
2. 2Write functions demonstrating pass-by-value, pass-by-pointer, and pass-by-reference
3. 3Inspect memory addresses using pointer arithmetic and raw byte casting (reinterpret_cast)
4. 4Verify memory alignments and struct padding with alignof and sizeof

You'll learn

• RAII — an idiom where resource lifecycle is bound to object lifetime via constructor and destructor
• Rule of Five — guideline specifying that if you declare copy/move constructors or destructors, you should declare all five
• AddressSanitizer — compiler instrumentation that detects out-of-bounds access and memory leaks at runtime

How to work through it

1. 1Implement a custom dynamic array class from scratch with constructor, destructor, and copy semantics
2. 2Observe undefined behavior and double-free issues when deep copies are omitted
3. 3Refactor the code to implement rule-of-five (copy/move constructors and assignment operators)
4. 4Test allocations with AddressSanitizer (-fsanitize=address) enabled in compiler flags

You'll learn

• Operator Overloading — defining custom behavior for standard operators like +, -, *, /
• Fixed-Point Representation — storing fractional numbers as integers scaled by a constant factor
• Unit Testing — automated validation of small units of source code against expected output

How to work through it

1. 1Define a templated class FixedPoint<int64_t, int DecimalPlaces>
2. 2Overload arithmetic operators (+, -, *, /) and comparison operators
3. 3Implement string conversion and stream insertion operators
4. 4Write unit tests with a test framework (doctest or GoogleTest) verifying no floating-point drift occurs

You'll learn

• Virtual Environments — isolated Python directories preventing dependency collisions across projects
• Type Hints — static typing annotations in Python verified via mypy
• Ruff — an extremely fast Python linter and code formatter written in Rust

How to work through it

1. 1Install Python 3.11+, uv or poetry, and set up an isolated project environment
2. 2Configure Ruff for linting and formatting, and mypy for static type annotations
3. 3Write a script verifying installation of NumPy, Pandas, Matplotlib, and SciPy
4. 4Run static type analysis and formatting checks from the command line

You'll learn

• OHLCV — Open, High, Low, Close, Volume candlestick summary of price activity over an interval
• VWAP — Volume-Weighted Average Price, a benchmark price measure used by execution traders
• Parquet — a column-oriented data file format designed for efficient data storage and retrieval

How to work through it

1. 1Obtain sample tick data CSVs (timestamp, price, volume, side)
2. 2Parse timestamps efficiently using Pandas datetime conversion
3. 3Apply resampling and grouping operations to calculate OHLCV aggregations and volume-weighted average prices (VWAP)
4. 4Filter outliers and export results to Parquet format for compact columnar storage

You'll learn

• Vectorization — performing operations on whole arrays at once via underlying C-level loops
• Log Returns — logarithmic differences representing continuous compounding
• Max Drawdown — the maximum observed loss from a peak to a trough of a portfolio before a new peak

How to work through it

1. 1Generate synthetic price paths using geometric random walks
2. 2Implement log return calculations using np.log and slice indexing
3. 3Calculate cumulative maximums and drawdown profiles without explicit loops
4. 4Benchmark and visualize performance differences using timeit

You'll learn

• Big-O Notation — mathematical notation describing the limiting behavior of an algorithm
• Contiguous Storage — storing elements adjacent in physical memory for fast sequential reads
• Pointer Chasing — following pointer chains across disconnected memory addresses, causing cache misses

How to work through it

1. 1Review asymptotic notation definitions (Worst, Average, Best case)
2. 2Profile element access, insertion at head/tail, and random insertion across std::vector and std::list
3. 3Document memory layout differences (contiguous memory vs fragmented node pointers)
4. 4Plot timing results as container sizes scale up to 1,000,000 elements

You'll learn

• Binary Heap — a complete binary tree that satisfies the heap property
• Sift Operations — logarithmic-time procedures to restore the heap property after insertion or deletion
• Implicit Tree Representation — storing a tree structure inside a flat array without pointers

How to work through it

1. 1Define a contiguous std::vector storage representation for the binary tree
2. 2Implement zero-indexed parent and child index arithmetic
3. 3Implement sift-up and sift-down rebalancing routines
4. 4Provide template support for arbitrary comparator functions

You'll learn

• Binary Search — logarithmic-time search algorithm in sorted arrays
• Branch Prediction — hardware CPU heuristics predicting the direction of conditional jumps
• Branchless Programming — writing logic without if-statements to prevent pipeline stalls

How to work through it

1. 1Implement a branchless binary search routine for sorted arrays
2. 2Create a container that stores sorted PriceLevel structures in a contiguous vector
3. 3Measure lookup times comparing branchless binary search against std::lower_bound
4. 4Add fast update-in-place operations for modifying existing volume

You'll learn

• Row-Major Order — storing consecutive matrix row elements in adjacent memory locations
• Dot Product — algebraic operation taking two equal-length sequences of numbers and returning a single scalar
• Covariance Matrix — a square matrix giving the covariances between each pair of asset returns

How to work through it

1. 1Review matrix operations, determinants, and matrix inversions
2. 2Implement a row-major 1D flat vector representation of a 2D matrix in C++
3. 3Implement naive matrix multiplication and cache-friendly transposed multiplication
4. 4Verify accuracy and numerical tolerances against NumPy

You'll learn

• OLS Regression — method for estimating unknown parameters in a linear regression model
• Beta — a measure of the volatility or systematic risk of an asset relative to the overall market
• T-Statistic — the ratio of the departure of the estimated value of a parameter from its hypothesized value to its standard error

How to work through it

1. 1Download two correlated stock time series (e.g., individual stock and SPY ETF)
2. 2Derive normal equations for slope and intercept (X^T * X)^(-1) * X^T * Y
3. 3Calculate residuals, variance, standard errors, and t-statistics
4. 4Plot residual histograms to evaluate normality assumptions

You'll learn

• Geometric Brownian Motion — continuous-time stochastic process where the logarithm of the quantity follows Brownian motion
• Wiener Process — continuous-time stochastic process with independent, normally distributed increments
• Euler-Maruyama Method — numerical technique for approximating solutions to stochastic differential equations

How to work through it

1. 1Review stochastic differential equations (SDEs) governing asset prices: dS = mu*S*dt + sigma*S*dW
2. 2Discretize the SDE using Euler-Maruyama approximation
3. 3Sample standard normal variables using the Box-Muller transform or std::normal_distribution
4. 4Visualize convergence of mean and standard deviation as sample sizes increase

You'll learn

• Rvalue References (&&) — references bound to temporary objects that can be safely moved from
• std::move — static cast converting an expression into an rvalue to enable move semantics
• noexcept Specifier — declaration indicating that a function will not throw exceptions, enabling critical STL optimizations

How to work through it

1. 1Write code triggering copy construction and copy assignment; measure the overhead
2. 2Implement move constructor and move assignment operator marked noexcept
3. 3Use std::vector::emplace_back and observe in-place construction
4. 4Trace object lifetimes using log prints in constructors and destructors

You'll learn

• C++20 Concepts — named boolean predicates evaluated at compile time to constrain template arguments
• constexpr & consteval — specifiers forcing expressions to be computed at compile time rather than runtime
• Vtable Elimination — avoiding dynamic dispatch tables to allow compiler inlining of critical path functions

How to work through it

1. 1Write traditional runtime polymorphism with base classes and virtual functions
2. 2Refactor the interface using Curiously Recurring Template Pattern (CRTP) and C++20 Concepts
3. 3Enforce constraints on template parameters using the requires clause
4. 4Compile and inspect the disassembly using Compiler Explorer (Godbolt) to verify that indirect call instructions (callq *) are eliminated

You'll learn

• pybind11 — lightweight header-only library exposing C++ types to Python
• Buffer Protocol — Python C-API interface allowing direct memory access between Python and native code without copying
• GIL (Global Interpreter Lock) — Python execution lock that must be released during long-running C++ calculations

How to work through it

1. 1Install pybind11 and configure CMake to build a shared library (.so / .pyd)
2. 2Wrap a C++ class and overload member methods for Python invocation
3. 3Implement zero-copy passing of NumPy arrays into C++ via py::array_t
4. 4Run automated pytest checks in Python testing the native C++ library

You'll learn

• Price-Time Priority (FIFO) — matching rule executing orders at the best price first, then ordered by arrival time
• Crossing Order — a buy order priced at or above the best ask, or sell order at or below the best bid
• Market Depth (L2/L3) — cumulative aggregated volume at price levels (L2) vs individual order tracking (L3)

How to work through it

1. 1Read academic and industry literature on modern market microstructure
2. 2Diagram the bid-ask spread, market depth, tick sizes, and lot sizes
3. 3Trace order matching step-by-step for crossing limit orders under FIFO priority
4. 4Document edge cases: partial fills, self-trade prevention, and cancel-replace requests

You'll learn

• FIX Protocol — international standard messaging protocol for real-time electronic financial transactions
• ITCH Protocol — binary protocol direct from exchanges carrying individual order additions, cancellations, and executions
• Endianness — the sequencing order of bytes in computer memory (network big-endian vs x86 little-endian)

How to work through it

1. 1Examine FIX 4.2/4.4 protocol specifications (fields like 35=MsgType, 11=ClOrdID, 44=Price, 38=OrderQty)
2. 2Examine NASDAQ TotalView-ITCH 5.0 binary protocol specifications
3. 3Write a C++ parser that reads binary packets directly into packed structs using memory offsets
4. 4Handle endianness conversion (big-endian network bytes to little-endian host architecture)

You'll learn

• Adverse Selection — risk that a trade occurs against a counterparty with superior private information
• Inventory Risk — the risk of loss due to holding asset inventory while market prices move against you
• Avellaneda-Stoikov Model — mathematical framework for optimal high-frequency quoting with inventory penalty

How to work through it

1. 1Study the Avellaneda-Stoikov market-making optimal quoting equations
2. 2Implement a discrete simulation environment where informed and uninformed traders arrive randomly
3. 3Compute optimal bid/ask spreads that adjust dynamically as inventory builds up
4. 4Evaluate profit-and-loss and inventory variance under different volatility regimes

You'll learn

• Cache Line — fixed-size block of memory (usually 64 bytes) transferred between main RAM and CPU caches
• TLB (Translation Lookaside Buffer) — cache storing recent physical-to-virtual memory address translations
• False Sharing — performance degradation where independent threads access distinct variables located on the same cache line

How to work through it

1. 1Review CPU memory architecture: cache lines (typically 64 bytes), caches, and Translation Lookaside Buffers (TLB)
2. 2Allocate a large buffer and shuffle pointer indices to ensure random access patterns
3. 3Measure average access cycles across increasing array sizes using std::chrono or RDTSC instruction
4. 4Graph latency vs array size to visualize the physical cache size thresholds

You'll learn

• Hardware Performance Counters — special registers in CPUs that track hardware events like cache misses and retired instructions
• Instructions Per Cycle (IPC) — metric indicating how efficiently the CPU pipeline is saturated
• Flame Graph — visualization of profiled software showing call stacks and their relative CPU consumption

How to work through it

1. 1Write a benchmark with an unsorted array causing frequent branch mispredictions in an if-statement
2. 2Run `perf stat` to measure branch-miss percentages and instructions per cycle (IPC)
3. 3Sort the array or refactor to branchless code and re-measure
4. 4Analyze flamegraphs using `perf record` and `perf report` to pinpoint execution hotspots

You'll learn

• CPU Pinning — binding an execution thread to a physical CPU core to eliminate context switching
• Core Isolation (isolcpus) — Linux kernel parameter preventing the OS scheduler from assigning general tasks to specified cores
• HugePages — memory pages of 2MB or 1GB size that reduce the number of entries needed in the TLB

How to work through it

1. 1Use sched_setaffinity and pthread_setaffinity_np to bind a running thread to a specific CPU core
2. 2Inspect thread affinities using htop, taskset, or /proc filesystems
3. 3Configure Linux HugePages (2MB / 1GB) and allocate memory via mmap with MAP_HUGETLB
4. 4Measure the jitter variance of a tight loop on a shared core versus a pinned core

You'll learn

• Data Race — concurrent access to a memory location by multiple threads where at least one is a write without synchronization
• Deadlock — situation where two or more threads are unable to proceed because each is waiting for the other to release a lock
• ThreadSanitizer (TSan) — compiler tool that detects data races in multithreaded programs

How to work through it

1. 1Create multiple threads writing to an unprotected shared vector and observe segfaults or data corruption
2. 2Protect critical sections using std::mutex and std::scoped_lock
3. 3Introduce a deliberate deadlock scenario by acquiring multiple mutexes in mismatched order
4. 4Compile with Clang ThreadSanitizer and verify detection of race conditions

You'll learn

• Atomic Operations — indivisible operations that complete without interruption from other threads
• Acquire-Release Semantics — memory barriers ensuring memory writes before a release are visible to threads after an acquire
• Compare-And-Swap (CAS) — atomic instruction that updates a memory location only if it matches an expected value

How to work through it

1. 1Review CPU instruction reordering and compiler reordering principles
2. 2Analyze atomic fetch-and-add and compare-and-swap (compare_exchange_strong/weak)
3. 3Construct a message publisher and subscriber passing data pointers via acquire-release atomics
4. 4Validate that no stale reads occur without relying on heavy mutex locks

You'll learn

• SPSC Ring Buffer — fixed-size circular queue allowing one reader and one writer to communicate without locks
• Hardware Destructive Interference Size — compiler constant providing the cache line size needed to prevent false sharing
• Wait-Free — an algorithm guaranteed to complete any operation in a bounded number of steps regardless of other threads

How to work through it

1. 1Define an array-backed ring buffer with fixed capacity (power of two for fast bitwise modulo)
2. 2Align head and tail atomic counters to distinct 64-byte cache lines with alignas
3. 3Implement push (producer only updates tail) and pop (consumer only updates head)
4. 4Benchmark throughput and measure percentiles (p50, p99, p99.9) using high-resolution timers

You'll learn

• epoll — scalable I/O event notification facility in the Linux kernel
• Edge-Triggered (EPOLLET) — event delivery model notifying the program only when the socket state changes
• Non-blocking I/O — socket operations that return immediately rather than waiting for data to arrive

How to work through it

1. 1Create non-blocking sockets using fcntl with O_NONBLOCK
2. 2Create an epoll instance with epoll_create1 and register sockets with epoll_ctl
3. 3Implement the event dispatch loop with epoll_wait handling EPOLLET (edge-triggered) events
4. 4Manage user-space connection state and read buffers to handle incomplete network frames

You'll learn

• UDP Multicast — one-to-many connectionless network broadcast method used in financial exchange feeds
• Packet Sequence Number — monotonic integers placed in packet headers to detect network dropouts
• SO_REUSEPORT — socket option allowing multiple sockets on the same host to bind to the same port

How to work through it

1. 1Create a UDP socket with SOCK_DGRAM and set SO_REUSEADDR and SO_REUSEPORT
2. 2Join an IP multicast group using the setsockopt IP_ADD_MEMBERSHIP command
3. 3Extract packet headers containing 64-bit sequence numbers
4. 4Maintain an internal state machine detecting sequence gaps and reporting loss statistics

You'll learn

• Kernel Bypass — technique allowing user-space applications to communicate directly with hardware adapters without OS mediation
• Poll-Mode Driver (PMD) — continuous polling loop reading NIC hardware descriptors without generating hardware interrupts
• Zero-Copy Networking — passing network payloads to application memory without copying between kernel and user buffers

How to work through it

1. 1Analyze the journey of a network packet from physical NIC PHY through ring buffers, interrupts, sk_buff, and POSIX read
2. 2Study how DPDK (Data Plane Development Kit) uses poll-mode drivers (PMDs) to read NIC queues directly
3. 3Evaluate OpenOnload transparent socket interception mechanics
4. 4Document the trade-offs: 100% CPU core pinning vs sub-microsecond latency gains

You'll learn

• Black-Scholes Model — mathematical model for pricing European-style options contracts
• Greeks — sensitivity measures of an option's price to changes in underlying parameters (Delta, Vega, Gamma)
• Put-Call Parity — fundamental static relationship between the price of a European call and put with the same strike and expiration

How to work through it

1. 1Derive the Black-Scholes formula for European calls and puts
2. 2Implement a high-precision cumulative normal distribution approximation (erf function)
3. 3Implement analytical formulas for Delta, Gamma, Vega, Theta, and Rho
4. 4Write unit tests verifying put-call parity holds across all calculations

You'll learn

• Monte Carlo Pricing — simulating thousands of price paths to compute expected derivative payoffs
• Xoroshiro / PCG — modern ultra-fast pseudo-random number generator algorithms
• Path-Dependent Options — financial derivatives whose payoff depends on the historical path of the asset, not just terminal price

How to work through it

1. 1Implement path generation for arithmetic Asian options with periodic price averaging
2. 2Parallelize path generation across CPU cores using std::jthread or OpenMP parallel for
3. 3Use fast pseudo-random number generators (Xoroshiro128+ or PCG) instead of slow std::mt19937
4. 4Profile and optimize memory access to ensure cores do not contend on shared counters

You'll learn

• Implied Volatility — the volatility value that equates theoretical option model price with market price
• Newton-Raphson Method — root-finding algorithm that produces successively better approximations to the roots of a real-valued function
• Vega — derivative of the option price with respect to the volatility of the underlying asset

How to work through it

1. 1Review Newton-Raphson root finding: x_{n+1} = x_n - f(x_n)/f'(x_n)
2. 2Formulate f(sigma) = BlackScholes(sigma) - MarketPrice, where f'(sigma) is Vega
3. 3Implement bounds checking to prevent negative volatilities and divergence
4. 4Expose the solver to Python and benchmark against SciPy's root finding

You'll learn

• Memory Pool — pre-allocated chunk of contiguous memory from which objects are allocated and returned without OS syscalls
• Double-Linked Order Queue — list enabling O(1) removal of cancelled orders from anywhere in the queue
• Intrusive Data Structures — containers where node pointers live directly inside the stored payload to eliminate pointer indirection

How to work through it

1. 1Design an Order struct packed to 32 or 64 bytes to optimize cache utilization
2. 2Implement a doubly linked list of Orders within each PriceLevel for O(1) cancellations
3. 3Implement pre-allocated object pools storing free lists of order nodes
4. 4Map price levels using an index-based lookup table or flat array for rapid access

You'll learn

• Matching Engine — software service responsible for pairing buyers and sellers at mutually agreeable prices
• Passive vs Aggressive Orders — orders adding liquidity to the book vs crossing the spread and taking liquidity
• Sweep — an aggressive order with enough volume to consume all liquidity across multiple consecutive price levels

How to work through it

1. 1Implement limit order insertion, cancellation, and modification routines
2. 2Implement matching loop crossing aggressive orders against resting bids/asks
3. 3Generate structured ExecutionReport events recording trade price, quantity, and matched IDs
4. 4Handle multi-level price sweeps when incoming order volume exceeds top of book

You'll learn

• Actor / Pipeline Architecture — concurrency pattern where threads own specific roles and communicate strictly via message queues
• Single-Writer Principle — architecture where only one thread mutates critical data structures to eliminate synchronization locks
• Jitter Minimization — eliminating standard deviation in execution time to achieve predictable latency

How to work through it

1. 1Create an Order Entry thread reading simulated requests and pushing to the input ring buffer
2. 2Run the matching engine on a dedicated, pinned core pulling from the input queue
3. 3Push execution reports and market data L2 top-of-book updates to the outbound queue
4. 4Run a market data publisher thread that consumes the outbound queue

You'll learn

• RDTSC — assembly instruction returning the number of clock cycles since the last CPU reset
• HDRHistogram — high dynamic range histogram designed for accurately recording latency without coordinated omission
• Tail Latency — the high percentile (p99, p99.9) latency events that represent worst-case system execution delays

How to work through it

1. 1Read CPU hardware timestamp counters using __builtin_ia32_rdtsc or std::chrono
2. 2Collect latency intervals into an HDRHistogram data structure to avoid measurement bias
3. 3Calculate p50, p90, p99, and p99.9 percentiles under high sustained load
4. 4Generate plots showing the latency distribution curve and analyze sources of tail spikes

You'll learn

• Fuzzing — automated testing technique providing invalid, unexpected, or random data as inputs to a computer program
• libFuzzer — in-process, coverage-guided fuzz testing library integrated into LLVM Clang
• Undefined Behavior — operations in C++ whose consequences are not prescribed by the language specification (e.g. signed overflow, out of bounds)

How to work through it

1. 1Write a fuzzer target function taking an array of raw bytes and feeding it to your parser
2. 2Compile with -fsanitize=fuzzer,address,undefined using Clang
3. 3Run libFuzzer across multiple cores allowing it to generate corpus test files
4. 4Patch any discovered memory leaks, buffer overruns, or infinite loop conditions

You'll learn

• Event-Driven Backtester — simulation model where each event (tick, order, fill) updates system state sequentially
• Slippage — difference between the expected price of a trade and the price at which the trade is executed
• Maker-Taker Fees — pricing structure where exchanges rebate makers for adding liquidity and charge takers for removing it

How to work through it

1. 1Implement discrete event simulation loop sorted by timestamp
2. 2Model realistic latency slippage (e.g., order reaches book 50 microseconds after signal)
3. 3Simulate queue position: an order only fills after existing passive volume at that price level is executed
4. 4Calculate gross and net PnL subtracting simulated maker/taker exchange fee tiers

You'll learn

• Bit Manipulation — performing direct operations on bitwise representations (e.g. power-of-two checks, population count)
• Vtable Internals — mechanics of how compilers lay out virtual method tables and pointers in memory
• Technical Communication — articulating complex low-level engineering decisions clearly under interview time pressure

How to work through it

1. 1Review classic C++ interview topics: vtables, object layouts, std::move traps, memory ordering
2. 2Practice low-level problems: bit manipulation tricks, fast integer formatting, custom vector allocators
3. 3Solve probability and expected value brainteasers common in trading firm screens
4. 4Conduct mock technical interview sessions explaining your design choices aloud

You'll learn

• Continuous Integration (CI) — practice of automating the building and testing of code every time a change is committed
• Clang-Tidy — Clang-based C++ linter tool providing static analysis and coding standard enforcement
• Technical Documentation — communicating system architecture, trade-offs, and verification results to other engineers

How to work through it

1. 1Write GitHub Actions CI configuration building on Linux with Clang and GCC under ASan and TSan
2. 2Run Clang-Format and Clang-Tidy to enforce clean style and static analysis compliance
3. 3Document architectural diagrams showing thread layouts, ring buffer connections, and memory maps
4. 4Publish benchmark methodology and reproducible latency figures in the project README