Who Should Take This and Prerequisites
This course is aimed at engineers who want to learn practical, low-latency algorithmic trading systems (HFT) implemented in C++ and Python. If you're a beginner in C++ & Python and have some experience in Java, C, or JavaScript, you'll fit right in — you'll reuse many concepts (threads, memory, async I/O) while learning new, performance-focused patterns.
Quick summary — should you take this?
- Yes if you: want to build latency-sensitive services, enjoy systems programming, and like squeezing performance out of code.
- Helpful background: basic programming in any language (
C++,Python,Java,C,JS) — we map transferable skills for each. - Not required but recommended: prior exposure to Linux, basic networking, and undergraduate-level probability/statistics.
Required foundations (the must-haves)
C++fundamentals: types, functions, classes/RAII, basic STL (vector,string), building withCMake.Pythonfundamentals: virtual environments,numpy,pandas, and writing/reading small scripts.- Math & statistics: basic probability, expectations, variance, simple time series intuition (moving averages).
- Operating systems: familiarity with Linux commands, processes/threads, and the idea of system calls.
- Networking basics: TCP vs UDP, sockets, and the concept of multicast (exchange market-data commonly uses UDP multicast).
Transferable skills from your background
- From
Java: concurrency models, threads, and JVM-managed memory — useful when learning C++ thread safety and memory management. - From
C: manual memory handling and low-level systems thinking — great prep for cache-awareness in C++. - From
JavaScript: async/event-driven patterns map nicely to event-loop-based market-data handlers.
Recommended readings & quick primers (2–10 hour windows)
C++: "A Tour of C++" (Bjarne Stroustrup) or a short C++ crash course coveringunique_ptr,move,std::vector.Python: Official tutorial + "Python Data Science Handbook" (Jake VanderPlas) chapters onnumpybasics.- Math/Stats: Khan Academy or a short refresher on probability & statistics (expectation, variance, conditional probability).
- OS/Networking: "Linux Basics for Hackers" (for CLI comfort) + simple socket tutorial (create a TCP and UDP echo server/client).
Preparatory exercises (small, hands-on; try 2–4 of these)
- Build and run a "Hello, build system" C++ program using
CMake. - In Python, load a CSV into
pandasand compute a rolling mean and standard deviation. - Write a small UDP sender and receiver (two programs) on your machine and observe packets with
tcpdump/wireshark. - Do a short probability exercise: compute expectation and variance of a discrete distribution.
Visual checklist (edit and track!)
1[✔] `Python` scripting & `numpy`
2[ ] `C++` basics: types, RAII, build with `CMake`
3[ ] Math & stats: probability, variance, moving averages
4[ ] Linux: basic shell, processes, top/htop
5[ ] Networking: sockets, UDP/TCP, pcap/tcpdumpShort analogy to keep things friendly
- Think of
Pythonas your playbook writer — quick to prototype plays (strategies). C++is the point guard who finishes the alley-oop — fast and disciplined.- Networking/OS knowledge is the stadium and court: if it's noisy or misconfigured, even the best play loses.
Challenge (interactive)
We've included a tiny, editable C++ program below. Edit the boolean flags at the top to reflect your current skills (flip false to true), recompile, and run it. The program prints a personalized prep plan and a checklist tuned to what you still need to study. If you're into basketball, change the favorite_player string to your favorite athlete (e.g., Kobe Bryant, LeBron James) for a bit of fun personalization.
Happy prepping — when you've completed 2–3 preparatory exercises from above, you'll be ready to jump into the first lab (environment setup and a minimal multicast listener).
xxxxxxxxxx}using namespace std;int main() { // EDIT THESE: set true when you feel comfortable with the topic const bool know_cpp = false; // types, RAII, STL, basic CMake const bool know_python = true; // venv, numpy, pandas const bool know_java = true; // transferable concurrency/OO skills const bool know_c = false; // low-level memory understanding const bool know_js = true; // async/event-driven patterns const bool know_os = false; // Linux basics, processes, threads const bool know_networking = false; // sockets, UDP/TCP, multicast const bool know_math_stats = false; // prob., expectation, variance const string favorite_player = "Kobe Bryant"; // change for fun cout << "HFT Course — Prerequisite Self-Check\n"; cout << "Favorite player (fun): " << favorite_player << "\n\n"; vector<string> todo; if (!know_cpp) todo.push_back("C++ crash course: types, RAII, smart pointers, basic STL, CMake setup"); if (!know_python) todo.push_back("Python: venv, numpy, pandas, small data processing scripts"); if (!know_math_stats) todo.push_back("Math/stats refresher: expectation, variance, simple time-series concepts"); if (!know_os) todo.push_back("Linux & OS basics: shell, processes, threads, profiling with top/htop"); if (!know_networking) todo.push_back("Networking: sockets (TCP/UDP), pcap/tcpdump, multicast basics"); if (know_java || know_c || know_js) {


