Course overview

Why Rust for Finance?

Memory safety, speed, and reliability — why quants and trading systems pick Rust over Python/C++/Java.

Printing & Formatting

Master println!, format!, debug {:?} prints, and numeric formatting you’ll use for prices and rates.

Comments, Style & Cargo Mindset

How Rust projects are organized locally, what the playground can/can’t do, and how to write readable quant code.

Variables, mut & Shadowing

let, mut, shadowing, and constants — immutability by default as a risk control.

Scalar Types Deep Dive

Integers, floats, bools, chars — choosing types for prices, sizes, and flags.

Tuples & Arrays Intro

Fixed-size groups of values: quote pairs, OHLC bars, and small matrices of numbers.

Functions & Return Values

Write reusable pricing helpers: parameters, returns, and expression-bodied functions.

if / else as Expressions

Branching with equal types in both arms — classify trades, regimes, and signs.

loop, while, and for

Iterate scenarios, days, and Monte Carlo seeds — break, continue, and ranges.

Module 1 Practice Lab

Capstone mini-lab: mini blotter combining variables, functions, formatting, and loops.

Stack, Heap & String

Where data lives, why String is different from string literals, and what Drop means.

Move Semantics

Assignment and function calls move non-Copy values; fix errors with clone or redesign.

Copy, Clone & Drop

When values duplicate cheaply, when clone is explicit, and when drop runs.

Immutable Borrows (&T)

Read data without taking ownership — the default for helpers and metrics.

Mutable Borrows (&mut T)

Exclusive write access — update positions and books safely.

Reading Borrow Checker Errors

Hand-holding through the most common compile errors and how to fix them.

String Slices (&str)

Views into string data — parsing symbols and message prefixes without copy.

Array/Slice Windows for Prices

&[T] views, slicing ranges, and SMA without copying the whole series.

Module 2 Lab: Quote Toolkit

Combine ownership ideas into a small quote helper library.

Struct Basics

Define Order and Quote structs, construct them, and compute simple fields.

impl Methods & Associated Functions

Position::new, market_value, and unrealized PnL with &self.

Tuple Structs & Newtypes

Price and Qty newtypes so you cannot mix units by accident.

Enums with Data

Side and OrderType — replace stringly-typed trading code.

Pattern Matching in Depth

Destructuring, match guards, and readable order-type descriptions.

Option Deep Dive

Some/None, map, unwrap_or, if let — no more null crashes.

Result Basics

Ok/Err for parsing prices and recoverable failures.

The ? Operator

Propagate errors in multi-field parsers without pyramid code.

Module 3 Lab: Order Ticket

Combine Side, Order, describe, notional, and validate.

Fixed Arrays [T; N]

Stack arrays, length in the type, and when interviews still use them.

Vec Interview Operations

push, pop, insert, remove, get, len, is_empty, clear — complexity and patterns.

Slices, windows & iteration patterns

Subarrays as slices, windows for pairs, enumerate for indices.

stdin Basics: lines & tokens

read_line, split_whitespace, parse — real stdin vs playground simulation.

Common Input Patterns

n then n lines; n m grid; until EOF; strings with spaces.

Real stdin API (copy-paste for local)

io::stdin, BufRead, fast-ish patterns you will use in contests.

HashMap Insert, Get, Update

insert, get, get_mut, contains_key — and owned String keys.

Remove, retain, drain, clear

remove returns old value; retain filters; clear empties.

Frequency Maps (classic)

Count characters/words; two-sum with HashMap; anagram check.

HashSet Insert, Contains, Remove

Unique elements, O(1) membership tests.

BTreeSet Ordered Uniques

Sorted unique keys; first/last; range queries mindset.

sort, reverse, binary_search

In-place sort on Vec; reverse; binary_search API.

Custom Sorting: sort_by & sort_by_key

Sort pairs, strings by length, structs by field — interview gold.

Sorting Structs & Argsort

Derive Ord or custom; indices argsort pattern.

Stack with Vec

push/pop back; valid parentheses; monotonic stack intro.

Queue with VecDeque

push_back + pop_front; BFS-ready queue.

Deque: Both Ends & Sliding Window

push/pop front and back; monotonic deque for sliding window max.

BinaryHeap Max-Heap

push, pop, peek — largest first.

Min-Heap with Reverse

std::cmp::Reverse wrapper — critical interview trick in Rust.

Heap Task: Meeting Rooms / Free Times

Sort intervals + min-heap of end times — classic interview combo.

Structure Cheat Sheet

Which structure for which problem — memorize this table.

Lab: LRU Cache Sketch (HashMap + order)

Interview favorite: O(1) get/put mental model; implement a simple O(n) version then discuss O(1).

Lab: End-to-End Mini Problem

Parse input, count with map, sort top frequencies, use heap optional.

Vec Basics

Growable arrays: push, indexing, capacity, and ownership.

Iterators: map, filter, collect

Transform price series without manual index soup.

windows & Log Returns

Pair consecutive prices into returns with windows(2).

HashMap Portfolios

Aggregate fills into net positions by ticker.

BTreeMap Order Levels

Sorted price levels for a toy limit book.

std Math & Formatting

f64 methods and format! for reports and d1.

Pipeline Lab: Prices to Stats

prices → returns → mean/std → annualized vol.

Module 4 Review Checklist

Counters with HashMap and self-check.

Error Handling Philosophy

When to Result, when to panic, how quant libs should fail.

Custom Error Enums

Typed errors you can match on.

Result Combinators & ?

map, and_then, and multi-step parsers.

Traits: Payoff Interface

Call/Put behind a trait.

Generics & Trait Bounds

One total_payoff for any Payoff type.

Common std Traits

Debug, Clone, Default, PartialEq on domain types.

Lifetimes Introduction

Why lifetimes exist; reading signatures that return references.

Module 5 Lab: Generic Pricer Boundary

Errors + Payoff trait + validated call.

Threads Basics

spawn, join, and move closures.

Channels (mpsc)

Message passing between workers and aggregator.

Sharing Read-Only Data

Arc for shared immutable inputs (spots, curves).

Mutex + Arc

Shared Vec of samples across threads.

Lock Hygiene & Deadlocks

Ordering locks and avoiding nested lock footguns.

Performance Mindset

Algorithm first, allocations, release builds, profiling instincts.

Module 6 Lab: Parallel Chunk Sum

Channel-based parallel reduction lab.

Cargo Project Layout

Folders, Cargo.toml, and lib vs bin.

Crates Map for Quants

What each popular crate is for — and when you need it.

Visibility & API Design

pub, pub(crate), and keeping internals private.

Data Shapes & Serde Mindset

Model ticks as structs; hand-parse CSV in playground.

Testing Quant Code

Approx equality, put-call parity checks, regression fixtures mindset.

Module 7 Lab: Mini stats Module

mod stats with mean/var/std and a parse_series helper.

Local Workflow Preview

rustup, cargo test, cargo bench mental model.

Simple vs Log Returns

Definitions, when to use which, and implementation pitfalls.

Realized Volatility

Sample std of returns and annualization conventions.

Drawdown Basics

Running peak and max drawdown on a wealth path.

Covariance

Aligned return series and sample covariance.

Correlation

rho = cov / (sx*sy) with zero-vol guards.

Seedable LCG Uniforms

Educational RNG: reproducibility and (0,1) mapping.

Box-Muller Normals

From uniforms to standard normals; check mean/std.

Module 8 Lab: Mini Risk Pack

Returns + vol + corr toolkit in one program.

Normal PDF & CDF

Abramowitz-Stegun style CDF approx and PDF.

d1 and d2 Explained

Interpret and implement the BS kernels.

Black-Scholes Call & Put

Full closed form with expiry edge cases.

Greeks: Delta & Vega

Analytic delta/vega and finite-difference checks.

Gamma & Theta Intuition

Formulas and qualitative behavior.

Binomial Tree (CRR)

Cox-Ross-Rubinstein European call.

Module 9 Lab: Vol Surface Slice

Price calls across strikes; print a simple smile-less curve.

GBM Intuition

SDE idea in words and the exact terminal solution.

Simulate Terminal Spots

MC estimate of E[S_T] vs theory.

Multi-Step Paths

Build a full path vector for path-dependent payoffs later.

MC European Call

Price with discounted mean payoff + standard error.

Compare MC to Black-Scholes

Cross-check methods; discuss bias vs variance.

Antithetic Variates

Pair Z and -Z to cut variance.

Module 10 Lab: MC Report Card

Print BS, MC, se, CI, and error vs BS.

Market Value

Sum qty * mark across a book.

Daily PnL

PnL from mark-to-mark moves.

Gross vs Net Exposure

Risk views beyond MV.

Historical VaR

Empirical quantile of PnL.

Expected Shortfall (CVaR)

Average loss beyond VaR.

Two-Asset Portfolio Vol

σ_p(w) formula and sweep.

Module 11 Lab: Risk Dashboard

Print MV, PnL, VaR, ES for a toy book history.

Order Book Design

Bids/asks maps, ticks, and invariants.

Mini Limit Order Book

Implement Book with add_bid/ask and BBO.

Pricer Trait Pattern

Abstract BS vs MC behind one interface.

Capstone: Mini Pricing Engine

Price a multi-leg options book with BS.

Architecture Notes

How real quant systems layer components.

Project Ideas

Concrete next builds with crate lists.

Final Checklist & Graduation

Confirm skills and declare your next project.