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 with CMake.
• Python fundamentals: 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 covering unique_ptr, move, std::vector.
• Python: Official tutorial + "Python Data Science Handbook" (Jake VanderPlas) chapters on numpy basics.
• 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 pandas and 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/tcpdump

Short analogy to keep things friendly

• Think of Python as 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

}

#include <iostream>

#include <vector>

#include <string>

​

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) {