Module 1: Environment & Tooling Setup

What Quantitative Development covers

Goal: Quantitative Development (QD) builds and runs the infrastructure that turns research into a live, automated system — data pipelines, execution engines, and the tooling around them.

The shape of this track: Modules 1–4 build shared research foundations (what a research edge is, how derivatives and markets work) — the same context a research analyst needs, because you can't build good infrastructure for a process you don't understand. Modules 5–6 go deep on two concrete systems: a data pipeline and a trade execution engine. Modules 7–10 are engineering practice and project time.

Module 1 focus: Nothing here is domain-specific yet — it's the generic setup every later module assumes you've already done.

Expected completion: end of Module 1

Python environment

Set up once, use all course long

Install Python 3.10+ and confirm it on your PATH (python --version)
Create a virtual environment per project (python -m venv .venv) rather than installing packages globally
Install the core data stack: pandas, numpy, matplotlib, and a notebook front-end (Jupyter or your editor's built-in notebook support)
Pick an editor (VS Code or PyCharm are the common choices) and install its Python extension
Verify the install: import pandas and numpy in a fresh script and print their versions

Why this matters: a global, unmanaged Python install is the single most common source of "it works on my machine" bugs. A per-project virtual environment costs two commands and prevents most of them.

Version control basics

What you need to be comfortable with by Module 2

Configure Git with your name and email (git config --global user.name/user.email)
Create a GitHub account if you don't have one, and set up SSH or a credential helper
Clone a repository and make your first commit on a branch, not on main
Understand the basic loop: branch → commit → push → open a pull request → review → merge
Know how to read a diff — what changed, and why it matters before you approve it

Why this matters: every system you touch from Module 5 onward lives in a shared repository. Git fluency isn't optional infrastructure — it's the mechanism by which your changes become other people's changes.

Reading a codebase before you write in it

A four-step habit

Start with the README. If there isn't one, that's information too — ask around before assuming.
Map the folder structure before you read any single file. Where does data come in? Where does logic live? Where are the tests?
Run the test suite before you change anything. A green baseline tells you what "still working" means.
Trace one function end to end — from where it's called to what it returns — before you extend it.

Why it matters: the fastest way to introduce a bug is to start writing before you understand what already exists. Orientation is not wasted time.

What's next

Module 2 preview: Derivatives & Contract Mechanics

Once your environment is working, Modules 2–4 cover the economic and market-structure foundations behind every strategy this course discusses — how futures and forwards work, what drives FX and commodity prices, and how fixed income and equity factors behave. By Module 5, you'll apply all of it while working through a real data pipeline's architecture.

Common mistakes

Five ways to make Module 2 harder than it needs to be

Installing packages globally. It works right up until two projects need different versions of the same library.
Skipping Git because "it's just me for now." The habits you build here are the ones you'll rely on in Module 5 under real time pressure.
Copy-pasting setup commands without reading what they do. If a command touches your system PATH or credentials, know why.
Diving into code before reading the README. Five minutes of orientation saves an hour of confusion.
Treating setup as busywork. A broken environment is the single most common reason later modules stall — get it right now.

← QD Course Home Module 2 →

Environment &Tooling Setup