Financial Engineering Programming

The Fixed Income track teaches what the numbers mean. This track teaches how the software that produces them is built — using a real, production-grade beta-calculation service (Java engine, HTTP API, Python verification) as the case study. Every module pairs the actual source code with a live interactive lab that lets you poke the idea: validate a record, step a binary search, cancel some floating point, evict from an LRU, break a fixture and watch the test catch it.

The case study, in one paragraph

A service that computes rolling beta from cached closing prices: validated immutable records flow into a read-optimized store (primitive arrays + binary search), pairs of tickers are aligned once and cached in an LRU, prefix sums make every query O(n) regardless of window size, a noise floor guards the math where floating point gets dangerous, a composition root wires it all with constructor injection — and a wall of tests plus an independent Python recomputation pin every number.

  1. 🧊
    Module 1Available

    Records & immutability

    Validated domain types: a price row that can never be half-valid, and why immutability is free thread-safety.

    🎛 Record validator

  2. 🗄️
    Module 2Available

    The read-optimized store

    Primitive arrays, epoch-day ints and binary search — what “cached at startup, optimized to read” actually means in code.

    🎛 Binary-search stepper

  3. ➕
    Module 3Available

    Prefix sums: O(1) window math

    Any window sum from two lookups and a subtraction — the trick that makes every rolling-beta query O(n), independent of window size.

    🎛 Window-sum explorer

  4. 🎯
    Module 4Available

    Floating point & the noise floor

    Catastrophic cancellation, the 1e-9 noise floor, and why numerical bugs serve confident wrong numbers instead of throwing.

    🎛 Cancellation lab

  5. ♻️
    Module 5Available

    Caching & concurrency

    A 10-line LRU from LinkedHashMap, value-based keys, and single-flight by construction from one synchronized monitor.

    🎛 LRU cache simulator

  6. 🧩
    Module 6Available

    Composition & DI without a framework

    Constructor injection, one typed composition root, and a strategy registry that makes new estimators a one-line extension.

    🎛 Registry & strategy demo

  7. ✅
    Module 7Available

    Testing the engine

    Known-value fixtures, textbook cross-checks to 1e-12, a performance proof, and a concurrency smoke test that pins single-flight.

    🎛 Fixture runner

  8. 🐍
    Module 8Available

    Python: independent verification & load testing

    IPV in pandas — same numbers, different code, different language — plus the load harness and synthetic data with known betas.

    🎛 IPV comparator

  9. #️⃣
    Module 9Available

    Hashing & hash maps

    From hashCode to bucket index: how the engine's O(1) lookups actually work — collisions, the equals contract, and why record keys can't lie.

    🎛 Hash map lab

  10. 🗑️
    Module 10Available

    Garbage collection & the JVM's options

    Generations, pauses and the collector menu — Serial, Parallel, G1, ZGC, Epsilon — and why the engine's best GC strategy is allocating less.

    🎛 GC simulator

Start with Module 1

Build a domain type that can't hold a bad value — the foundation everything else stands on.

Open records & immutability →

Educational analysis, not investment advice. Code excerpts are from a real reference implementation.